javascript/49614.html">java/237239.html">java 多线程详解
在这篇文章里，我们关注多线程。多线程是一个复杂的话题，包含了很多内容，这篇文章主要关注线程的基本属性、如何创建线程、线程的状态切换以及线程通信。
线程是操作系统运行的基本单位，它被封装在进程中，一个进程可以包含多个线程。即使我们不手动创造线程，进程也会有一个默认的线程在运行。
对于JVM来说，当我们编写一个单线程的程序去运行时，JVM中也是有至少两个线程在运行，一个是我们创建的程序，一个是垃圾回收。
线程基本信息
我们可以通过Thread.currentThread()方法获取当前线程的一些信息，并对其进行修改。
我们来看以下代码：
查看并修改当前线程的属性String name = Thread.currentThread().getName(); int priority = Thread.currentThread().getPriority(); String groupName = Thread.currentThread().getThreadGroup().getName(); boolean isDaemon = Thread.currentThread().isDaemon(); System.out.println("Thread Name:" + name); System.out.println("Priority:" + priority); System.out.println("Group Name:" + groupName); System.out.println("IsDaemon:" + isDaemon); Thread.currentThread().setName("Test"); Thread.currentThread().setPriority(Thread.MAX_PRIORITY); name = Thread.currentThread().getName(); priority = Thread.currentThread().getPriority(); groupName = Thread.currentThread().getThreadGroup().getName(); isDaemon = Thread.currentThread().isDaemon(); System.out.println("Thread Name:" + name); System.out.println("Priority:" + priority);其中列出的属性说明如下：
我们可以看下面的代码，它定义了两个不同优先级的线程：
线程优先级示例public static void priorityTest(){ Thread thread1 = new Thread("low") { public void run() { for (int i = 0; i < 5; i++) { System.out.println("Thread 1 is running."); } } }; Thread thread2 = new Thread("high") { public void run() { for (int i = 0; i < 5; i++) { System.out.println("Thread 2 is running."); } } }; thread1.setPriority(Thread.MIN_PRIORITY); thread2.setPriority(Thread.MAX_PRIORITY); thread1.start(); thread2.start();}从运行结果可以看出，是高优先级线程运行完成后，低优先级线程才运行。
isDaemon，这个属性用来控制父子线程的关系，如果设置为true，当父线程结束后，其下所有子线程也结束，反之，子线程的生命周期不受父线程影响。
我们来看下面的例子：
IsDaemon 示例public static void daemonTest(){ Thread thread1 = new Thread("daemon") { public void run() { Thread subThread = new Thread("sub") { public void run() { for(int i = 0; i < 100; i++) { System.out.println("Sub Thread Running " + i); } } }; subThread.setDaemon(true); subThread.start(); System.out.println("Main Thread end."); } }; thread1.start();}上面代码的运行结果，在和删除subThread.setDaemon(true);后对比，可以发现后者运行过程中子线程会完成执行后再结束，而前者中，子线程很快就结束了。
如何创建线程
上面的内容，都是演示默认线程中的一些信息，那么应该如何创建线程呢？在Java中，我们有3种方式可以用来创建线程。
Java中的线程要么继承Thread类，要么实现Runnable接口，我们一一道来。
使用内部类来创建线程
我们可以使用内部类的方式来创建线程，过程是声明一个Thread类型的变量，并重写run方法。示例代码如下：
使用内部类创建线程public static void createThreadByNestClass(){ Thread thread = new Thread() { public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); } }; thread.start();}继承Thread以创建线程
我们可以从Thread中派生一个类，重写其run方法，这种方式和上面相似。示例代码如下：
派生Thread类以创建线程class MyThread extends Thread{ public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); }}public static void createThreadBySubClass(){ MyThread thread = new MyThread(); thread.start();}实现Runnable接口以创建线程
我们可以定义一个类，使其实现Runnable接口，然后将该类的实例作为构建Thread变量构造函数的参数。示例代码如下：
实现Runnable接口以创建线程class MyRunnable implements Runnable{ public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); }}public static void createThreadByRunnable(){ MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start();}上述3种方式都可以创建线程，而且从示例代码上看，线程执行的功能是一样的，那么这三种创建方式有什么不同呢？
这涉及到Java中多线程的运行模式，对于Java来说，多线程在运行时，有“多对象多线程”和“单对象多线程”的区别：
显然，从线程同步和调度的角度来看，多对象多线程要简单一些。上述3种线程创建方式，前两种都属于“多对象多线程”，第三种既可以使用“多对象多线程”，也可以使用“单对象单线程”。
我们来看下面的示例代码，里面会用到Object.notify方法，这个方法会唤醒对象上的一个线程；而Object.notifyAll方法，则会唤醒对象上的所有线程。
notify示例public class NotifySample { public static void main(String[] args) throws InterruptedException { notifyTest(); notifyTest2(); notifyTest3(); } private static void notifyTest() throws InterruptedException { MyThread[] arrThreads = new MyThread[3]; for (int i = 0; i < arrThreads.length; i++) { arrThreads[i] = new MyThread(); arrThreads[i].id = i; arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); for (int i = 0; i < arrThreads.length; i++) { synchronized(arrThreads[i]) { arrThreads[i].notify(); } } } private static void notifyTest2() throws InterruptedException { MyRunner[] arrMyRunners = new MyRunner[3]; Thread[] arrThreads = new Thread[3]; for (int i = 0; i < arrThreads.length; i++) { arrMyRunners[i] = new MyRunner(); arrMyRunners[i].id = i; arrThreads[i] = new Thread(arrMyRunners[i]); arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); for (int i = 0; i < arrMyRunners.length; i++) { synchronized(arrMyRunners[i]) { arrMyRunners[i].notify(); } } } private static void notifyTest3() throws InterruptedException { MyRunner runner = new MyRunner(); Thread[] arrThreads = new Thread[3]; for (int i = 0; i < arrThreads.length; i++) { arrThreads[i] = new Thread(runner); arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); synchronized(runner) { runner.notifyAll(); } }}class MyThread extends Thread{ public int id = 0; public void run() { System.out.println("第" + id + "个线程准备休眠5分钟。"); try { synchronized(this) { this.wait(5*60*1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } System.out.println("第" + id + "个线程被唤醒。"); }}class MyRunner implements Runnable{ public int id = 0; public void run() { System.out.println("第" + id + "个线程准备休眠5分钟。"); try { synchronized(this) { this.wait(5*60*1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } System.out.println("第" + id + "个线程被唤醒。"); } }示例代码中，notifyTest()和notifyTest2()是“多对象多线程”，尽管notifyTest2()中的线程实现了Runnable接口，但是它里面定义Thread数组时，每个元素都使用了一个新的Runnable实例。notifyTest3()属于“单对象多线程”，因为我们只定义了一个Runnable实例，所有的线程都会使用这个实例。
notifyAll方法适用于“单对象多线程”的情景，因为notify方法只会随机唤醒对象上的一个线程。
线程的状态切换
对于线程来讲，从我们创建它一直到线程运行结束，在这个过程中，线程的状态可能是这样的：
下面我们来演示如何进行线程状态切换，首先我们会用到下面方法：
下面，就是演示时间啦！！！
线程等待与唤醒
这里主要使用Object.wait和Object.notify方法，请参见上面的notify实例。需要注意的是，wait和notify都必须针对同一个对象，当我们使用实现Runnable接口的方式来创建线程时，应该是在Runnable对象而非Thread对象上使用这两个方法。
线程的休眠与唤醒
Thread.sleep实例public class SleepSample { public static void main(String[] args) throws InterruptedException { sleepTest(); } private static void sleepTest() throws InterruptedException { Thread thread = new Thread() { public void run() { System.out.println("线程 " + Thread.currentThread().getName() + "将要休眠5分钟。"); try { Thread.sleep(5*60*1000); } catch(InterruptedException ex) { System.out.println("线程 " + Thread.currentThread().getName() + "休眠被中断。"); } System.out.println("线程 " + Thread.currentThread().getName() + "休眠结束。"); } }; thread.setDaemon(true); thread.start(); Thread.sleep(500); thread.interrupt(); }}线程在休眠过程中，我们可以使用Thread.interrupt将其唤醒，这时线程会抛出InterruptedException。
线程的终止
虽然有Thread.stop方法，但该方法是不被推荐使用的，我们可以利用上面休眠与唤醒的机制，让线程在处理IterruptedException时，结束线程。
Thread.interrupt示例public class StopThreadSample { public static void main(String[] args) throws InterruptedException { stopTest(); } private static void stopTest() throws InterruptedException { Thread thread = new Thread() { public void run() { System.out.println("线程运行中。"); try { Thread.sleep(1*60*1000); } catch(InterruptedException ex) { System.out.println("线程中断，结束线程"); return; } System.out.println("线程正常结束。"); } }; thread.start(); Thread.sleep(500); thread.interrupt(); }}线程的同步等待
当我们在主线程中创建了10个子线程，然后我们期望10个子线程全部结束后，主线程在执行接下来的逻辑，这时，就该Thread.join登场了。
Thread.join示例public class JoinSample { public static void main(String[] args) throws InterruptedException { joinTest(); } private static void joinTest() throws InterruptedException { Thread thread = new Thread() { public void run() { try { for(int i = 0; i < 5; i++) { System.out.println("线程在运行。"); Thread.sleep(1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } } }; thread.setDaemon(true); thread.start(); Thread.sleep(1000); thread.join(); System.out.println("主线程正常结束。"); }}我们可以试着将thread.join();注释或者删除，再次运行程序，就可以发现不同了。
线程间通信
我们知道，一个进程下面的所有线程是共享内存空间的，那么我们如何在不同的线程之间传递消息呢？在回顾 Java I/O时，我们谈到了PipedStream和PipedReader，这里，就是它们发挥作用的地方了。
下面的两个示例，功能完全一样，不同的是一个使用Stream，一个使用Reader/Writer。
PipeInputStream/PipedOutpueStream 示例public static void communicationTest() throws IOException, InterruptedException{ final PipedOutputStream pos = new PipedOutputStream(); final PipedInputStream pis = new PipedInputStream(pos); Thread thread1 = new Thread() { public void run() { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); try { while(true) { String message = br.readLine(); pos.write(message.getBytes()); if (message.equals("end")) break; } br.close(); pos.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; Thread thread2 = new Thread() { public void run() { byte[] buffer = new byte[1024]; int bytesRead = 0; try { while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1) { System.out.println(new String(buffer)); if (new String(buffer).equals("end")) break; buffer = null; buffer = new byte[1024]; } pis.close(); buffer = null; } catch(Exception ex) { ex.printStackTrace(); } } }; thread1.setDaemon(true); thread2.setDaemon(true); thread1.start(); thread2.start(); thread1.join(); thread2.join();}
PipedReader/PipedWriter 示例private static void communicationTest2() throws InterruptedException, IOException{ final PipedWriter pw = new PipedWriter(); final PipedReader pr = new PipedReader(pw); final BufferedWriter bw = new BufferedWriter(pw); final BufferedReader br = new BufferedReader(pr); Thread thread1 = new Thread() { public void run() { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); try { while(true) { String message = br.readLine(); bw.write(message); bw.newLine(); bw.flush(); if (message.equals("end")) break; } br.close(); pw.close(); bw.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; Thread thread2 = new Thread() { public void run() { String line = null; try { while((line = br.readLine()) != null) { System.out.println(line); if (line.equals("end")) break; } br.close(); pr.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; thread1.setDaemon(true); thread2.setDaemon(true); thread1.start(); thread2.start(); thread1.join(); thread2.join();}感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
新闻热点
疑难解答
图片精选
