Java併發編程：如何建立線程？

時間  2019-11-16
標籤 java 併發 編程 如何 建立 線程 欄目 Java 简体版
原文   原文鏈接

‍

在前面一篇文章中已經講述了在進程和線程的由來，今天就來說一下在Java中如何建立線程，讓線程去執行一個子任務。下面先講述一下Java中的應用程序和進程相關的概念知識，而後再闡述如何建立線程以及如何建立進程。下面是本文的目錄大綱：html

一.Java中關於應用程序和進程相關的概念java

二.Java中如何建立線程程序員

三.Java中如何建立進程web

一.Java中關於應用程序和進程相關的概念編程

在Java中，一個應用程序對應着一個JVM實例（也有地方稱爲JVM進程），通常來講名字默認爲java.exe或者javaw.exe（windows下能夠經過任務管理器查看）。Java採用的是單線程編程模型，即在咱們本身的程序中若是沒有主動建立線程的話，只會建立一個線程，一般稱爲主線程。可是要注意，雖然只有一個線程來執行任務，不表明JVM中只有一個線程，JVM實例在建立的時候，同時會建立不少其餘的線程（好比垃圾收集器線程）。windows

因爲Java採用的是單線程編程模型，所以在進行UI編程時要注意將耗時的操做放在子線程中進行，以免阻塞主線程（在UI編程時，主線程即UI線程，用來處理用戶的交互事件）。架構

二.Java中如何建立線程app

在java中若是要建立線程的話，通常有兩種方式：1）繼承Thread類；2）實現Runnable接口。ide

　　1.繼承Thread類網站

繼承Thread類的話，必須重寫run方法，在run方法中定義須要執行的任務。

1
2
3
4
5
6
7
8
9
10
11
12
class MyThread extends Thread{
  private static int num = 0 ;
 
  public MyThread(){
  num++;
  }
 
  @Override
  public void run() {
  System.out.println( "主動建立的第" +num+ "個線程" );
  }
}

建立好了本身的線程類以後，就能夠建立線程對象了，而後經過start()方法去啓動線程。注意，不是調用run()方法啓動線程，run方法中只是定義須要執行的任務，若是調用run方法，即至關於在主線程中執行run方法，跟普通的方法調用沒有任何區別，此時並不會建立一個新的線程來執行定義的任務。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test {
  public static void main(String[] args) {
  MyThread thread = new MyThread();
  thread.start();
  }
}
 
class MyThread extends Thread{
  private static int num = 0 ;
 
  public MyThread(){
  num++;
  }
 
  @Override
  public void run() {
  System.out.println( "主動建立的第" +num+ "個線程" );
  }
}

在上面代碼中，經過調用start()方法，就會建立一個新的線程了。爲了分清start()方法調用和run()方法調用的區別，請看下面一個例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Test {
  public static void main(String[] args) {
  System.out.println( "主線程ID:" +Thread.currentThread().getId());
  MyThread thread1 = new MyThread( "thread1" );
  thread1.start();
  MyThread thread2 = new MyThread( "thread2" );
  thread2.run();
  }
}
 
class MyThread extends Thread{
  private String name;
 
  public MyThread(String name){
  this .name = name;
  }
 
  @Override
  public void run() {
  System.out.println( "name:" +name+ " 子線程ID:" +Thread.currentThread().getId());
  }
}

運行結果：

從輸出結果能夠得出如下結論：

1）thread1和thread2的線程ID不一樣，thread2和主線程ID相同，說明經過run方法調用並不會建立新的線程，而是在主線程中直接運行run方法，跟普通的方法調用沒有任何區別；

2）雖然thread1的start方法調用在thread2的run方法前面調用，可是先輸出的是thread2的run方法調用的相關信息，說明新線程建立的過程不會阻塞主線程的後續執行。

2.實現Runnable接口

在Java中建立線程除了繼承Thread類以外，還能夠經過實現Runnable接口來實現相似的功能。實現Runnable接口必須重寫其run方法。

下面是一個例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test {
  public static void main(String[] args) {
  System.out.println( "主線程ID：" +Thread.currentThread().getId());
  MyRunnable runnable = new MyRunnable();
  Thread thread = new Thread(runnable);
  thread.start();
  }
}
 
class MyRunnable implements Runnable{
 
  public MyRunnable() {
 
  }
 
  @Override
  public void run() {
  System.out.println( "子線程ID：" +Thread.currentThread().getId());
  }
}

Runnable的中文意思是「任務」，顧名思義，經過實現Runnable接口，咱們定義了一個子任務，而後將子任務交由Thread去執行。注意，這種方式必須將Runnable做爲Thread類的參數，而後經過Thread的start方法來建立一個新線程來執行該子任務。若是調用Runnable的run方法的話，是不會建立新線程的，這根普通的方法調用沒有任何區別。

事實上，查看Thread類的實現源代碼會發現Thread類是實現了Runnable接口的。

在Java中，這2種方式均可以用來建立線程去執行子任務，具體選擇哪種方式要看本身的需求。直接繼承Thread類的話，可能比實現Runnable接口看起來更加簡潔，可是因爲Java只容許單繼承，因此若是自定義類須要繼承其餘類，則只能選擇實現Runnable接口。

三.Java中如何建立進程

在Java中，能夠經過兩種方式來建立進程，總共涉及到5個主要的類。

第一種方式是經過Runtime.exec()方法來建立一個進程，第二種方法是經過ProcessBuilder的start方法來建立進程。下面就來說一講這2種方式的區別和聯繫。

首先要講的是Process類，Process類是一個抽象類，在它裏面主要有幾個抽象的方法，這個能夠經過查看Process類的源代碼得知：

位於java.lang.Process路徑下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class Process
{
 
  abstract public OutputStream getOutputStream(); //獲取進程的輸出流
 
  abstract public InputStream getInputStream(); //獲取進程的輸入流
 
  abstract public InputStream getErrorStream(); //獲取進程的錯誤流
 
  abstract public int waitFor() throws InterruptedException; //讓進程等待
 
  abstract public int exitValue(); //獲取進程的退出標誌
 
  abstract public void destroy(); //摧毀進程
}

　1）經過ProcessBuilder建立進程

ProcessBuilder是一個final類，它有兩個構造器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public final class ProcessBuilder
{
  private List<String> command;
  private File directory;
  private Map<String,String> environment;
  private boolean redirectErrorStream;
 
  public ProcessBuilder(List<String> command) {
  if (command == null )
  throw new NullPointerException();
  this .command = command;
  }
 
  public ProcessBuilder(String... command) {
  this .command = new ArrayList<String>(command.length);
  for (String arg : command)
  this .command.add(arg);
  }
....
}

構造器中傳遞的是須要建立的進程的命令參數，第一個構造器是將命令參數放進List當中傳進去，第二構造器是以不定長字符串的形式傳進去。

那麼咱們接着往下看，前面提到是經過ProcessBuilder的start方法來建立一個新進程的，咱們看一下start方法中具體作了哪些事情。下面是start方法的具體實現源代碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public Process start() throws IOException {
// Must convert to array first -- a malicious user-supplied
// list might try to circumvent the security check.
String[] cmdarray = command.toArray( new String[command.size()]);
for (String arg : cmdarray)
  if (arg == null )
  throw new NullPointerException();
// Throws IndexOutOfBoundsException if command is empty
String prog = cmdarray[ 0 ];
 
SecurityManager security = System.getSecurityManager();
if (security != null )
  security.checkExec(prog);
 
String dir = directory == null ? null : directory.toString();
 
try {
  return ProcessImpl.start(cmdarray,
  environment,
  dir,
  redirectErrorStream);
} catch (IOException e) {
  // It's much easier for us to create a high-quality error
  // message than the low-level C code which found the problem.
  throw new IOException(
  "Cannot run program \"" + prog + "\""
  + (dir == null ? "" : " (in directory \"" + dir + "\")" )
  + ": " + e.getMessage(),
  e);
}
}

該方法返回一個Process對象，該方法的前面部分至關因而根據命令參數以及設置的工做目錄進行一些參數設定，最重要的是try語句塊裏面的一句：

1
2
3
4
return ProcessImpl.start(cmdarray,
  environment,
  dir,
  redirectErrorStream);

說明真正建立進程的是這一句，注意調用的是ProcessImpl類的start方法，此處能夠知道start必然是一個靜態方法。那麼ProcessImpl又是什麼類呢？該類一樣位於java.lang.ProcessImpl路徑下，看一下該類的具體實現：

ProcessImpl也是一個final類，它繼承了Process類：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final class ProcessImpl extends Process {
 
  // System-dependent portion of ProcessBuilder.start()
  static Process start(String cmdarray[],
  java.util.Map<String,String> environment,
  String dir,
  boolean redirectErrorStream)
  throws IOException
  {
  String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
  return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);
  }
  ....
}

這是ProcessImpl類的start方法的具體實現，而事實上start方法中是經過這句來建立一個ProcessImpl對象的：

1
return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);

而在ProcessImpl中對Process類中的幾個抽象方法進行了具體實現。

說明事實上經過ProcessBuilder的start方法建立的是一個ProcessImpl對象。

下面看一下具體使用ProcessBuilder建立進程的例子，好比我要經過ProcessBuilder來啓動一個進程打開cmd，並獲取ip地址信息，那麼能夠這麼寫：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
  public static void main(String[] args) throws IOException {
  ProcessBuilder pb = new ProcessBuilder( "cmd" , "/c" , "ipconfig/all" );
  Process process = pb.start();
  Scanner scanner = new Scanner(process.getInputStream());
 
  while (scanner.hasNextLine()){
  System.out.println(scanner.nextLine());
  }
  scanner.close();
  }
}

第一步是最關鍵的，就是將命令字符串傳給ProcessBuilder的構造器，通常來講，是把字符串中的每一個獨立的命令做爲一個單獨的參數，不過也能夠按照順序放入List中傳進去。

至於其餘不少具體的用法不在此進行贅述，好比經過ProcessBuilder的environment方法和directory(File directory)設置進程的環境變量以及工做目錄等，感興趣的朋友能夠查看相關API文檔。

　　2）經過Runtime的exec方法來建立進程

首先仍是來看一下Runtime類和exec方法的具體實現，Runtime，顧名思義，即運行時，表示當前進程所在的虛擬機實例。

因爲任何進程只會運行於一個虛擬機實例當中，因此在Runtime中採用了單例模式，即只會產生一個虛擬機實例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Runtime {
  private static Runtime currentRuntime = new Runtime();
 
  /**
  * Returns the runtime object associated with the current Java application.
  * Most of the methods of class <code>Runtime</code> are instance
  * methods and must be invoked with respect to the current runtime object.
  *
  * @return the <code>Runtime</code> object associated with the current
  * Java application.
  */
  public static Runtime getRuntime() {
  return currentRuntime;
  }
 
  /** Don't let anyone else instantiate this class */
  private Runtime() {}
  ...
  }

從這裏能夠看出，因爲Runtime類的構造器是private的，因此只有經過getRuntime去獲取Runtime的實例。接下來着重看一下exec方法 實現，在Runtime中有多個exec的不一樣重載實現，但真正最後執行的是這個版本的exec方法：

1
2
3
4
5
6
7
public Process exec(String[] cmdarray, String[] envp, File dir)
  throws IOException {
  return new ProcessBuilder(cmdarray)
  .environment(envp)
  .directory(dir)
  .start();
  }

能夠發現，事實上經過Runtime類的exec建立進程的話，最終仍是經過ProcessBuilder類的start方法來建立的。

下面看一個例子，看一下經過Runtime的exec如何建立進程，仍是前面的例子，調用cmd，獲取ip地址信息：

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
  public static void main(String[] args) throws IOException {
  String cmd = "cmd " + "/c " + "ipconfig/all" ;
  Process process = Runtime.getRuntime().exec(cmd);
  Scanner scanner = new Scanner(process.getInputStream());
 
  while (scanner.hasNextLine()){
  System.out.println(scanner.nextLine());
  }
  scanner.close();
  }
}

要注意的是，exec方法不支持不定長參數（ProcessBuilder是支持不定長參數的），因此必須先把命令參數拼接好再傳進去。

關於在Java中如何建立線程和進程的話，暫時就講這麼多了，感興趣的朋友能夠參考相關資料、

參考資料：

http://luckykapok918.blog.163.com/blog/static/205865043201210272168556/

http://www.cnblogs.com/ChrisWang/archive/2009/12/02/use-java-lang-process-and-processbuilder-to-create-native-application-process.html

http://lavasoft.blog.51cto.com/62575/15662/

問啊-一鍵呼叫程序員答題神器，牛人一對一服務，開發者編程必備官方網站：www.wenaaa.com

QQ羣290551701 彙集不少互聯網精英，技術總監，架構師，項目經理！開源技術研究，歡迎業內人士，大牛及新手有志於從事IT行業人員進入！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程