Java回顾之多线程
添加时间:2013-5-5 点击量:
第一篇：Java回顾之I/O
第二篇：Java回顾之收集通信
在这篇文章里，我们存眷多线程。多线程是一个错杂的话题，包含了很多内容，这篇文章首要存眷线程的根蒂根基属性、如何创建线程、线程的状况切换以及线程通信，我们把线程同步的话题留到下一篇文章中。
线程是操纵体系运行的根蒂根基单位，它被封装在过程中，一个过程可以包含多个线程。即使我们不手动发明线程，过程也会有一个默认的线程在运行。
对于JVM来说，编写一个单线程的法度去运行时，JVM中也是有至少两个线程在运行，一个是我们创建的法度，一个是垃圾收受接管。
线程根蒂根基信息
我们可以经由过程Thread.currentThread（）办法获取当火线程的一些信息，并对其进行批改。
我们来看以下代码：
查看并批改当火线程的属性
1 String name = Thread.currentThread（）.getName（）;
2 int priority = Thread.currentThread（）.getPriority（）;
3 String groupName = Thread.currentThread（）.getThreadGroup（）.getName（）;
4 boolean isDaemon = Thread.currentThread（）.isDaemon（）;
5 System.out.println（Thread Name: + name）;
6 System.out.println（Priority: + priority）;
7 System.out.println（Group Name: + groupName）;
8 System.out.println（IsDaemon: + isDaemon）;
9
10 Thread.currentThread（）.setName（Test）;
11 Thread.currentThread（）.setPriority（Thread.MAX_PRIORITY）;
12 name = Thread.currentThread（）.getName（）;
13 priority = Thread.currentThread（）.getPriority（）;
14 groupName = Thread.currentThread（）.getThreadGroup（）.getName（）;
15 isDaemon = Thread.currentThread（）.isDaemon（）;
16 System.out.println（Thread Name: + name）;
17 System.out.println（Priority: + priority）;
此中列出的属性申明如下：
- GroupName，每个线程都邑默认在一个线程组里，我们也可以显式的创建线程组，一个线程组中也可以包含子线程组，如许线程和线程组，就构成了一个树状布局。
- Name，每个线程都邑有一个名字，若是不显式指定，那么名字的规矩是“Thread-xxx”。
- Priority，每个线程都邑有本身的优先级，JVM对优先级的处理惩罚体式格式是“抢占式”的。当JVM发明优先级高的线程时，即速运行该线程；对于多个优先级相等的线程，JVM对其进行轮询处理惩罚。Java的线程优先级从1到10，默认是5，Thread类定义了2个常量：MIN_PRIORITY和MAX_PRIORITY来默示高和最低优先级。
我们可以看下面的代码，它定义了两个不合优先级的线程：
线程优先级示例
1 public static void priorityTest（）
2 {
3 Thread thread1 = new Thread（low）
4 {
5 public void run（）
6 {
7 for （int i = 0; i < 5; i++）
8 {
9 System.out.println（Thread 1 is running.）;
10 }
11 }
12 };
13
14 Thread thread2 = new Thread（high）
15 {
16 public void run（）
17 {
18 for （int i = 0; i < 5; i++）
19 {
20 System.out.println（Thread 2 is running.）;
21 }
22 }
23 };
24
25 thread1.setPriority（Thread.MIN_PRIORITY）;
26 thread2.setPriority（Thread.MAX_PRIORITY）;
27 thread1.start（）;
28 thread2.start（）;
29 }
从运行成果可以看出，是高优先级线程运行完成后，低优先级线程才运行。
- isDaemon，这个属性用来把握父子线程的关系，若是设置为true，当父线程停止后，其下所有子线程也停止，反之，子线程的生命周期不受父线程影响。
我们来看下面的例子：
IsDaemon 示例
1 public static void daemonTest（）
2 {
3 Thread thread1 = new Thread（daemon）
4 {
5 public void run（）
6 {
7 Thread subThread = new Thread（sub）
8 {
9 public void run（）
10 {
11 for（int i = 0; i < 100; i++）
12 {
13 System.out.println（Sub Thread Running + i）;
14 }
15 }
16 };
17 subThread.setDaemon（true）;
18 subThread.start（）;
19 System.out.println（Main Thread end.）;
20 }
21 };
22
23 thread1.start（）;
24 }
上方代码的运行成果，在和删除subThread.setDaemon（true）;后对比，可以发明后者运行过程中子线程会完成履行后再停止，而前者中，子线程很快就停止了。
如何创建线程
上方的内容，都是演示默认线程中的一些信息，那么应当如何创建线程呢？在Java中，我们有3种体式格式可以用来创建线程。
Java中的线程要么持续Thread类，要么实现Runnable接口，我们一一道来。
应用内部类来创建线程
我们可以应用内部类的体式格式来创建线程，过程是声明一个Thread类型的变量，并重写run办法。示例代码如下：
应用内部类创建线程
1 public static void createThreadByNestClass（）
2 {
3 Thread thread = new Thread（）
4 {
5 public void run（）
6 {
7 for （int i =0; i < 5; i++）
8 {
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
10 }
11 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
12 }
13 };
14 thread.start（）;
15 }
持续Thread以创建线程
我们可以从Thread中派生一个类，重写其run办法，这种体式格式和上方类似。示例代码如下：
派生Thread类以创建线程
1 class MyThread extends Thread
2 {
3 public void run（）
4 {
5 for （int i =0; i < 5; i++）
6 {
7 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
8 }
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
10 }
11 }
12
13
14 public static void createThreadBySubClass（）
15 {
16 MyThread thread = new MyThread（）;
17 thread.start（）;
18 }
实现Runnable接口以创建线程
我们可以定义一个类，使其实现Runnable接口，然后将该类的实例作为构建Thread变量机关函数的参数。示例代码如下：
实现Runnable接口以创建线程
1 class MyRunnable implements Runnable
2 {
3 public void run（）
4 {
5 for （int i =0; i < 5; i++）
6 {
7 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
8 }
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
10 }
11 }
12
13
14 public static void createThreadByRunnable（）
15 {
16 MyRunnable runnable = new MyRunnable（）;
17 Thread thread = new Thread（runnable）;
18 thread.start（）;
19 }
上述3种体式格式都可以创建线程，并且从示例代码上看，线程履行的功能是一样的，那么这三种创建体式格式有什么不合呢？
这涉及到Java中多线程的运行模式，对于Java来说，多线程在运行时，有“多对象多线程”和“单对象多线程”的差别：
- 多对象多线程，法度在运行过程中创建多个线程对象，每个对象上运行一个线程。
- 单对象多线程，法度在运行过程中创建一个线程对象，在其上运行多个线程。
显然，从线程同步和调剂的角度来看，多对象多线程要简单一些。上述3种线程创建体式格式，前两种都属于“多对象多线程”，第三种既可以应用“多对象多线程”，也可以应用“单对象单线程”。
我们来看下面的示例代码，里面会用到Object.notify办法，这个办唤醒对象上的一个线程；而Object.notifyAll办法，则会唤醒对象上的所有线程。
notify示例
1 public class NotifySample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 notifyTest（）;
6 notifyTest2（）;
7 notifyTest3（）;
8 }
9
10 private static void notifyTest（） throws InterruptedException
11 {
12 MyThread[] arrThreads = new MyThread[3];
13 for （int i = 0; i < arrThreads.length; i++）
14 {
15 arrThreads[i] = new MyThread（）;
16 arrThreads[i].id = i;
17 arrThreads[i].setDaemon（true）;
18 arrThreads[i].start（）;
19 }
20 Thread.sleep（500）;
21 for （int i = 0; i < arrThreads.length; i++）
22 {
23 synchronized（arrThreads[i]）
24 {
25 arrThreads[i].notify（）;
26 }
27 }
28 }
29
30 private static void notifyTest2（） throws InterruptedException
31 {
32 MyRunner[] arrMyRunners = new MyRunner[3];
33 Thread[] arrThreads = new Thread[3];
34 for （int i = 0; i < arrThreads.length; i++）
35 {
36 arrMyRunners[i] = new MyRunner（）;
37 arrMyRunners[i].id = i;
38 arrThreads[i] = new Thread（arrMyRunners[i]）;
39 arrThreads[i].setDaemon（true）;
40 arrThreads[i].start（）;
41 }
42 Thread.sleep（500）;
43 for （int i = 0; i < arrMyRunners.length; i++）
44 {
45 synchronized（arrMyRunners[i]）
46 {
47 arrMyRunners[i].notify（）;
48 }
49 }
50 }
51
52 private static void notifyTest3（） throws InterruptedException
53 {
54 MyRunner runner = new MyRunner（）;
55 Thread[] arrThreads = new Thread[3];
56 for （int i = 0; i < arrThreads.length; i++）
57 {
58 arrThreads[i] = new Thread（runner）;
59 arrThreads[i].setDaemon（true）;
60 arrThreads[i].start（）;
61 }
62 Thread.sleep（500）;
63
64 synchronized（runner）
65 {
66 runner.notifyAll（）;
67 }
68 }
69 }
70
71 class MyThread extends Thread
72 {
73 public int id = 0;
74 public void run（）
75 {
76 System.out.println（第 + id + 个线程筹办休眠5分钟。）;
77 try
78 {
79 synchronized（this）
80 {
81 this.wait（5601000）;
82 }
83 }
84 catch（InterruptedException ex）
85 {
86 ex.printStackTrace（）;
87 }
88 System.out.println（第 + id + 个线程被唤醒。）;
89 }
90 }
91
92 class MyRunner implements Runnable
93 {
94 public int id = 0;
95 public void run（）
96 {
97 System.out.println（第 + id + 个线程筹办休眠5分钟。）;
98 try
99 {
100 synchronized（this）
101 {
102 this.wait（5601000）;
103 }
104 }
105 catch（InterruptedException ex）
106 {
107 ex.printStackTrace（）;
108 }
109 System.out.println（第 + id + 个线程被唤醒。）;
110 }
111
112 }
示例代码中，notifyTest（）和notifyTest2（）是“多对象多线程”，尽管notifyTest2（）中的线程实现了Runnable接口，然则它里面定义Thread数组时，每个元素都应用了一个新的Runnable实例。notifyTest3（）属于“单对象多线程”，因为我们只定义了一个Runnable实例，所有的线程都邑应用这个实例。
notifyAll办法实用于“单对象多线程”的情景，因为notify办法只会随机唤醒对象上的一个线程。
线程的状况切换
对于线程来讲，从我们创建它一向到线程运行停止，在这个过程中，线程的状况可能是如许的：
- 创建：已经有Thread实例了， 然则CPU还有为其分派资料和时候片。
- 伏贴：线程已经获得了运行所需的所有资料，只等CPU进行时候调剂。
- 运行：线程位于当前CPU时候片中，正在履行相干逻辑。
- 休眠：一般是调用Thread.sleep后的状况，这时线程依然持有运行所需的各类资料，然则不会被CPU调剂。
- 挂起：一般是调用Thread.suspend后的状况，和休眠类似，CPU不会调剂该线程，不合的是，这种状况下，线程会开释所有资料。
- 灭亡：线程运行停止或者调用了Thread.stop办法。
下面我们来演示如何进行线程状况切换，起首我们会用到下面办法：
- Thread（）或者Thread（Runnable）：机关线程。
- Thread.start：启动线程。
- Thread.sleep：将线程切换至休眠状况。
- Thread.interrupt：中断线程的履行。
- Thread.join：守候某线程停止。
- Thread.yield：剥夺线程在CPU上的履行时候片，守候下一次调剂。
- Object.wait：将Object上所有线程锁定，直到notify办法才持续运行。
- Object.notify：随机唤醒Object上的1个线程。
- Object.notifyAll：唤醒Object上的所有线程。
下面，就是演示时候啦！！！
线程守候与唤醒
这里首要应用Object.wait和Object.notify办法，请拜见上方的notify实例。须要重视的是，wait和notify都必须针对同一个对象，应用实现Runnable接口的体式格式来创建线程时，应当是在Runnable对象而非Thread对象上应用这两个办法。
线程的休眠与唤醒
Thread.sleep实例
1 public class SleepSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 sleepTest（）;
6 }
7
8 private static void sleepTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 System.out.println（线程 + Thread.currentThread（）.getName（） + 将要休眠5分钟。）;
15 try
16 {
17 Thread.sleep（5601000）;
18 }
19 catch（InterruptedException ex）
20 {
21 System.out.println（线程 + Thread.currentThread（）.getName（） + 休眠被中断。）;
22 }
23 System.out.println（线程 + Thread.currentThread（）.getName（） + 休眠停止。）;
24 }
25 };
26 thread.setDaemon（true）;
27 thread.start（）;
28 Thread.sleep（500）;
29 thread.interrupt（）;
30 }
31
32 }
线程在休眠过程中，我们可以应用Thread.interrupt将其唤醒，这时线程会抛出InterruptedException。
线程的终止
固然有Thread.stop办法，但该办法是不被推荐应用的，我们可以哄骗上方休眠与唤醒的机制，让线程在处理惩罚IterruptedException时，停止线程。
Thread.interrupt示例
1 public class StopThreadSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 stopTest（）;
6 }
7
8 private static void stopTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 System.out.println（线程运行中。）;
15 try
16 {
17 Thread.sleep（1601000）;
18 }
19 catch（InterruptedException ex）
20 {
21 System.out.println（线程中断，停止线程）;
22 return;
23 }
24 System.out.println（线程正常停止。）;
25 }
26 };
27 thread.start（）;
28 Thread.sleep（500）;
29 thread.interrupt（）;
30 }
31 }
线程的同步守候
在主线程中创建了10个子线程，然后我们期望10个子线程全部停止后，主线程在履行接下来的逻辑，这时，就该Thread.join登场了。
Thread.join示例
1 public class JoinSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 joinTest（）;
6 }
7
8 private static void joinTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 try
15 {
16 for（int i = 0; i < 5; i++）
17 {
18 System.out.println（线程在运行。）;
19 Thread.sleep（1000）;
20 }
21 }
22 catch（InterruptedException ex）
23 {
24 ex.printStackTrace（）;
25 }
26 }
27 };
28 thread.setDaemon（true）;
29 thread.start（）;
30 Thread.sleep（1000）;
31 thread.join（）;
32 System.out.println（主线程正常停止。）;
33 }
34 }
我们可以试着将thread.join（）;注释或者删除，再次运行法度，就可以发明不合了。
线程间通信
我们知道，一个过程下面的所有线程是共享内存空间的，那么我们如安在不合的线程之间传递消息呢？在回顾 Java I/O时，我们谈到了PipedStream和PipedReader，这里，就是它们阐扬感化的处所了。
下面的两个示例，功能完全一样，不合的是一个应用Stream，一个应用Reader/Writer。
PipeInputStream/PipedOutpueStream 示例
1 public static void communicationTest（） throws IOException， InterruptedException
2 {
3 final PipedOutputStream pos = new PipedOutputStream（）;
4 final PipedInputStream pis = new PipedInputStream（pos）;
5
6 Thread thread1 = new Thread（）
7 {
8 public void run（）
9 {
10 BufferedReader br = new BufferedReader（new InputStreamReader（System.in））;
11 try
12 {
13 while（true）
14 {
15 String message = br.readLine（）;
16 pos.write（message.getBytes（））;
17 if （message.equals（end）） break;
18 }
19 br.close（）;
20 pos.close（）;
21 }
22 catch（Exception ex）
23 {
24 ex.printStackTrace（）;
25 }
26 }
27 };
28
29 Thread thread2 = new Thread（）
30 {
31 public void run（）
32 {
33 byte[] buffer = new byte[1024];
34 int bytesRead = 0;
35 try
36 {
37 while（（bytesRead = pis.read（buffer， 0， buffer.length）） != -1）
38 {
39 System.out.println（new String（buffer））;
40 if （new String（buffer）.equals（end）） break;
41 buffer = null;
42 buffer = new byte[1024];
43 }
44 pis.close（）;
45 buffer = null;
46 }
47 catch（Exception ex）
48 {
49 ex.printStackTrace（）;
50 }
51 }
52 };
53
54 thread1.setDaemon（true）;
55 thread2.setDaemon（true）;
56 thread1.start（）;
57 thread2.start（）;
58 thread1.join（）;
59 thread2.join（）;
60 }
PipedReader/PipedWriter 示例
1 private static void communicationTest2（） throws InterruptedException， IOException
2 {
3 final PipedWriter pw = new PipedWriter（）;
4 final PipedReader pr = new PipedReader（pw）;
5 final BufferedWriter bw = new BufferedWriter（pw）;
6 final BufferedReader br = new BufferedReader（pr）;
7
8 Thread thread1 = new Thread（）
9 {
10 public void run（）
11 {
12
13 BufferedReader br = new BufferedReader（new InputStreamReader（System.in））;
14 try
15 {
16 while（true）
17 {
18 String message = br.readLine（）;
19 bw.write（message）;
20 bw.newLine（）;
21 bw.flush（）;
22 if （message.equals（end）） break;
23 }
24 br.close（）;
25 pw.close（）;
26 bw.close（）;
27 }
28 catch（Exception ex）
29 {
30 ex.printStackTrace（）;
31 }
32 }
33 };
34
35 Thread thread2 = new Thread（）
36 {
37 public void run（）
38 {
39
40 String line = null;
41 try
42 {
43 while（（line = br.readLine（）） != null）
44 {
45 System.out.println（line）;
46 if （line.equals（end）） break;
47 }
48 br.close（）;
49 pr.close（）;
50 }
51 catch（Exception ex）
52 {
53 ex.printStackTrace（）;
54 }
55 }
56 };
57
58 thread1.setDaemon（true）;
59 thread2.setDaemon（true）;
60 thread1.start（）;
61 thread2.start（）;
62 thread1.join（）;
63 thread2.join（）;
64 }
这篇文章就到这里，我们会鄙人一篇里，评论辩论同步的话题。
原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#
第一篇：Java回顾之I/O
第二篇：Java回顾之收集通信
在这篇文章里，我们存眷多线程。多线程是一个错杂的话题，包含了很多内容，这篇文章首要存眷线程的根蒂根基属性、如何创建线程、线程的状况切换以及线程通信，我们把线程同步的话题留到下一篇文章中。
线程是操纵体系运行的根蒂根基单位，它被封装在过程中，一个过程可以包含多个线程。即使我们不手动发明线程，过程也会有一个默认的线程在运行。
对于JVM来说，编写一个单线程的法度去运行时，JVM中也是有至少两个线程在运行，一个是我们创建的法度，一个是垃圾收受接管。
线程根蒂根基信息
我们可以经由过程Thread.currentThread（）办法获取当火线程的一些信息，并对其进行批改。
我们来看以下代码：
查看并批改当火线程的属性
1 String name = Thread.currentThread（）.getName（）;
2 int priority = Thread.currentThread（）.getPriority（）;
3 String groupName = Thread.currentThread（）.getThreadGroup（）.getName（）;
4 boolean isDaemon = Thread.currentThread（）.isDaemon（）;
5 System.out.println（Thread Name: + name）;
6 System.out.println（Priority: + priority）;
7 System.out.println（Group Name: + groupName）;
8 System.out.println（IsDaemon: + isDaemon）;
9
10 Thread.currentThread（）.setName（Test）;
11 Thread.currentThread（）.setPriority（Thread.MAX_PRIORITY）;
12 name = Thread.currentThread（）.getName（）;
13 priority = Thread.currentThread（）.getPriority（）;
14 groupName = Thread.currentThread（）.getThreadGroup（）.getName（）;
15 isDaemon = Thread.currentThread（）.isDaemon（）;
16 System.out.println（Thread Name: + name）;
17 System.out.println（Priority: + priority）;
此中列出的属性申明如下：
- GroupName，每个线程都邑默认在一个线程组里，我们也可以显式的创建线程组，一个线程组中也可以包含子线程组，如许线程和线程组，就构成了一个树状布局。
- Name，每个线程都邑有一个名字，若是不显式指定，那么名字的规矩是“Thread-xxx”。
- Priority，每个线程都邑有本身的优先级，JVM对优先级的处理惩罚体式格式是“抢占式”的。当JVM发明优先级高的线程时，即速运行该线程；对于多个优先级相等的线程，JVM对其进行轮询处理惩罚。Java的线程优先级从1到10，默认是5，Thread类定义了2个常量：MIN_PRIORITY和MAX_PRIORITY来默示高和最低优先级。
我们可以看下面的代码，它定义了两个不合优先级的线程：
线程优先级示例
1 public static void priorityTest（）
2 {
3 Thread thread1 = new Thread（low）
4 {
5 public void run（）
6 {
7 for （int i = 0; i < 5; i++）
8 {
9 System.out.println（Thread 1 is running.）;
10 }
11 }
12 };
13
14 Thread thread2 = new Thread（high）
15 {
16 public void run（）
17 {
18 for （int i = 0; i < 5; i++）
19 {
20 System.out.println（Thread 2 is running.）;
21 }
22 }
23 };
24
25 thread1.setPriority（Thread.MIN_PRIORITY）;
26 thread2.setPriority（Thread.MAX_PRIORITY）;
27 thread1.start（）;
28 thread2.start（）;
29 }
从运行成果可以看出，是高优先级线程运行完成后，低优先级线程才运行。 - isDaemon，这个属性用来把握父子线程的关系，若是设置为true，当父线程停止后，其下所有子线程也停止，反之，子线程的生命周期不受父线程影响。
我们来看下面的例子：
IsDaemon 示例
1 public static void daemonTest（）
2 {
3 Thread thread1 = new Thread（daemon）
4 {
5 public void run（）
6 {
7 Thread subThread = new Thread（sub）
8 {
9 public void run（）
10 {
11 for（int i = 0; i < 100; i++）
12 {
13 System.out.println（Sub Thread Running + i）;
14 }
15 }
16 };
17 subThread.setDaemon（true）;
18 subThread.start（）;
19 System.out.println（Main Thread end.）;
20 }
21 };
22
23 thread1.start（）;
24 }上方代码的运行成果，在和删除subThread.setDaemon（true）;后对比，可以发明后者运行过程中子线程会完成履行后再停止，而前者中，子线程很快就停止了。
如何创建线程
上方的内容，都是演示默认线程中的一些信息，那么应当如何创建线程呢？在Java中，我们有3种体式格式可以用来创建线程。
Java中的线程要么持续Thread类，要么实现Runnable接口，我们一一道来。
应用内部类来创建线程
我们可以应用内部类的体式格式来创建线程，过程是声明一个Thread类型的变量，并重写run办法。示例代码如下：
应用内部类创建线程
1 public static void createThreadByNestClass（）
2 {
3 Thread thread = new Thread（）
4 {
5 public void run（）
6 {
7 for （int i =0; i < 5; i++）
8 {
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
10 }
11 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
12 }
13 };
14 thread.start（）;
15 }
持续Thread以创建线程
我们可以从Thread中派生一个类，重写其run办法，这种体式格式和上方类似。示例代码如下：
派生Thread类以创建线程
1 class MyThread extends Thread
2 {
3 public void run（）
4 {
5 for （int i =0; i < 5; i++）
6 {
7 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
8 }
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
10 }
11 }
12
13
14 public static void createThreadBySubClass（）
15 {
16 MyThread thread = new MyThread（）;
17 thread.start（）;
18 }
实现Runnable接口以创建线程
我们可以定义一个类，使其实现Runnable接口，然后将该类的实例作为构建Thread变量机关函数的参数。示例代码如下：
实现Runnable接口以创建线程
1 class MyRunnable implements Runnable
2 {
3 public void run（）
4 {
5 for （int i =0; i < 5; i++）
6 {
7 System.out.println（Thread + Thread.currentThread（）.getName（） + is running.）;
8 }
9 System.out.println（Thread + Thread.currentThread（）.getName（） + is finished.）;
10 }
11 }
12
13
14 public static void createThreadByRunnable（）
15 {
16 MyRunnable runnable = new MyRunnable（）;
17 Thread thread = new Thread（runnable）;
18 thread.start（）;
19 }
上述3种体式格式都可以创建线程，并且从示例代码上看，线程履行的功能是一样的，那么这三种创建体式格式有什么不合呢？
这涉及到Java中多线程的运行模式，对于Java来说，多线程在运行时，有“多对象多线程”和“单对象多线程”的差别：
- 多对象多线程，法度在运行过程中创建多个线程对象，每个对象上运行一个线程。
- 单对象多线程，法度在运行过程中创建一个线程对象，在其上运行多个线程。
显然，从线程同步和调剂的角度来看，多对象多线程要简单一些。上述3种线程创建体式格式，前两种都属于“多对象多线程”，第三种既可以应用“多对象多线程”，也可以应用“单对象单线程”。
我们来看下面的示例代码，里面会用到Object.notify办法，这个办唤醒对象上的一个线程；而Object.notifyAll办法，则会唤醒对象上的所有线程。
notify示例
1 public class NotifySample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 notifyTest（）;
6 notifyTest2（）;
7 notifyTest3（）;
8 }
9
10 private static void notifyTest（） throws InterruptedException
11 {
12 MyThread[] arrThreads = new MyThread[3];
13 for （int i = 0; i < arrThreads.length; i++）
14 {
15 arrThreads[i] = new MyThread（）;
16 arrThreads[i].id = i;
17 arrThreads[i].setDaemon（true）;
18 arrThreads[i].start（）;
19 }
20 Thread.sleep（500）;
21 for （int i = 0; i < arrThreads.length; i++）
22 {
23 synchronized（arrThreads[i]）
24 {
25 arrThreads[i].notify（）;
26 }
27 }
28 }
29
30 private static void notifyTest2（） throws InterruptedException
31 {
32 MyRunner[] arrMyRunners = new MyRunner[3];
33 Thread[] arrThreads = new Thread[3];
34 for （int i = 0; i < arrThreads.length; i++）
35 {
36 arrMyRunners[i] = new MyRunner（）;
37 arrMyRunners[i].id = i;
38 arrThreads[i] = new Thread（arrMyRunners[i]）;
39 arrThreads[i].setDaemon（true）;
40 arrThreads[i].start（）;
41 }
42 Thread.sleep（500）;
43 for （int i = 0; i < arrMyRunners.length; i++）
44 {
45 synchronized（arrMyRunners[i]）
46 {
47 arrMyRunners[i].notify（）;
48 }
49 }
50 }
51
52 private static void notifyTest3（） throws InterruptedException
53 {
54 MyRunner runner = new MyRunner（）;
55 Thread[] arrThreads = new Thread[3];
56 for （int i = 0; i < arrThreads.length; i++）
57 {
58 arrThreads[i] = new Thread（runner）;
59 arrThreads[i].setDaemon（true）;
60 arrThreads[i].start（）;
61 }
62 Thread.sleep（500）;
63
64 synchronized（runner）
65 {
66 runner.notifyAll（）;
67 }
68 }
69 }
70
71 class MyThread extends Thread
72 {
73 public int id = 0;
74 public void run（）
75 {
76 System.out.println（第 + id + 个线程筹办休眠5分钟。）;
77 try
78 {
79 synchronized（this）
80 {
81 this.wait（5601000）;
82 }
83 }
84 catch（InterruptedException ex）
85 {
86 ex.printStackTrace（）;
87 }
88 System.out.println（第 + id + 个线程被唤醒。）;
89 }
90 }
91
92 class MyRunner implements Runnable
93 {
94 public int id = 0;
95 public void run（）
96 {
97 System.out.println（第 + id + 个线程筹办休眠5分钟。）;
98 try
99 {
100 synchronized（this）
101 {
102 this.wait（5601000）;
103 }
104 }
105 catch（InterruptedException ex）
106 {
107 ex.printStackTrace（）;
108 }
109 System.out.println（第 + id + 个线程被唤醒。）;
110 }
111
112 }
示例代码中，notifyTest（）和notifyTest2（）是“多对象多线程”，尽管notifyTest2（）中的线程实现了Runnable接口，然则它里面定义Thread数组时，每个元素都应用了一个新的Runnable实例。notifyTest3（）属于“单对象多线程”，因为我们只定义了一个Runnable实例，所有的线程都邑应用这个实例。
notifyAll办法实用于“单对象多线程”的情景，因为notify办法只会随机唤醒对象上的一个线程。
线程的状况切换
对于线程来讲，从我们创建它一向到线程运行停止，在这个过程中，线程的状况可能是如许的：
- 创建：已经有Thread实例了， 然则CPU还有为其分派资料和时候片。
- 伏贴：线程已经获得了运行所需的所有资料，只等CPU进行时候调剂。
- 运行：线程位于当前CPU时候片中，正在履行相干逻辑。
- 休眠：一般是调用Thread.sleep后的状况，这时线程依然持有运行所需的各类资料，然则不会被CPU调剂。
- 挂起：一般是调用Thread.suspend后的状况，和休眠类似，CPU不会调剂该线程，不合的是，这种状况下，线程会开释所有资料。
- 灭亡：线程运行停止或者调用了Thread.stop办法。
下面我们来演示如何进行线程状况切换，起首我们会用到下面办法：
- Thread（）或者Thread（Runnable）：机关线程。
- Thread.start：启动线程。
- Thread.sleep：将线程切换至休眠状况。
- Thread.interrupt：中断线程的履行。
- Thread.join：守候某线程停止。
- Thread.yield：剥夺线程在CPU上的履行时候片，守候下一次调剂。
- Object.wait：将Object上所有线程锁定，直到notify办法才持续运行。
- Object.notify：随机唤醒Object上的1个线程。
- Object.notifyAll：唤醒Object上的所有线程。
下面，就是演示时候啦！！！
线程守候与唤醒
这里首要应用Object.wait和Object.notify办法，请拜见上方的notify实例。须要重视的是，wait和notify都必须针对同一个对象，应用实现Runnable接口的体式格式来创建线程时，应当是在Runnable对象而非Thread对象上应用这两个办法。
线程的休眠与唤醒
Thread.sleep实例
1 public class SleepSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 sleepTest（）;
6 }
7
8 private static void sleepTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 System.out.println（线程 + Thread.currentThread（）.getName（） + 将要休眠5分钟。）;
15 try
16 {
17 Thread.sleep（5601000）;
18 }
19 catch（InterruptedException ex）
20 {
21 System.out.println（线程 + Thread.currentThread（）.getName（） + 休眠被中断。）;
22 }
23 System.out.println（线程 + Thread.currentThread（）.getName（） + 休眠停止。）;
24 }
25 };
26 thread.setDaemon（true）;
27 thread.start（）;
28 Thread.sleep（500）;
29 thread.interrupt（）;
30 }
31
32 }
线程在休眠过程中，我们可以应用Thread.interrupt将其唤醒，这时线程会抛出InterruptedException。
线程的终止
固然有Thread.stop办法，但该办法是不被推荐应用的，我们可以哄骗上方休眠与唤醒的机制，让线程在处理惩罚IterruptedException时，停止线程。
Thread.interrupt示例
1 public class StopThreadSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 stopTest（）;
6 }
7
8 private static void stopTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 System.out.println（线程运行中。）;
15 try
16 {
17 Thread.sleep（1601000）;
18 }
19 catch（InterruptedException ex）
20 {
21 System.out.println（线程中断，停止线程）;
22 return;
23 }
24 System.out.println（线程正常停止。）;
25 }
26 };
27 thread.start（）;
28 Thread.sleep（500）;
29 thread.interrupt（）;
30 }
31 }
线程的同步守候
在主线程中创建了10个子线程，然后我们期望10个子线程全部停止后，主线程在履行接下来的逻辑，这时，就该Thread.join登场了。
Thread.join示例
1 public class JoinSample {
2
3 public static void main（String[] args） throws InterruptedException
4 {
5 joinTest（）;
6 }
7
8 private static void joinTest（） throws InterruptedException
9 {
10 Thread thread = new Thread（）
11 {
12 public void run（）
13 {
14 try
15 {
16 for（int i = 0; i < 5; i++）
17 {
18 System.out.println（线程在运行。）;
19 Thread.sleep（1000）;
20 }
21 }
22 catch（InterruptedException ex）
23 {
24 ex.printStackTrace（）;
25 }
26 }
27 };
28 thread.setDaemon（true）;
29 thread.start（）;
30 Thread.sleep（1000）;
31 thread.join（）;
32 System.out.println（主线程正常停止。）;
33 }
34 }
我们可以试着将thread.join（）;注释或者删除，再次运行法度，就可以发明不合了。
线程间通信
我们知道，一个过程下面的所有线程是共享内存空间的，那么我们如安在不合的线程之间传递消息呢？在回顾 Java I/O时，我们谈到了PipedStream和PipedReader，这里，就是它们阐扬感化的处所了。
下面的两个示例，功能完全一样，不合的是一个应用Stream，一个应用Reader/Writer。
PipeInputStream/PipedOutpueStream 示例
1 public static void communicationTest（） throws IOException， InterruptedException
2 {
3 final PipedOutputStream pos = new PipedOutputStream（）;
4 final PipedInputStream pis = new PipedInputStream（pos）;
5
6 Thread thread1 = new Thread（）
7 {
8 public void run（）
9 {
10 BufferedReader br = new BufferedReader（new InputStreamReader（System.in））;
11 try
12 {
13 while（true）
14 {
15 String message = br.readLine（）;
16 pos.write（message.getBytes（））;
17 if （message.equals（end）） break;
18 }
19 br.close（）;
20 pos.close（）;
21 }
22 catch（Exception ex）
23 {
24 ex.printStackTrace（）;
25 }
26 }
27 };
28
29 Thread thread2 = new Thread（）
30 {
31 public void run（）
32 {
33 byte[] buffer = new byte[1024];
34 int bytesRead = 0;
35 try
36 {
37 while（（bytesRead = pis.read（buffer， 0， buffer.length）） != -1）
38 {
39 System.out.println（new String（buffer））;
40 if （new String（buffer）.equals（end）） break;
41 buffer = null;
42 buffer = new byte[1024];
43 }
44 pis.close（）;
45 buffer = null;
46 }
47 catch（Exception ex）
48 {
49 ex.printStackTrace（）;
50 }
51 }
52 };
53
54 thread1.setDaemon（true）;
55 thread2.setDaemon（true）;
56 thread1.start（）;
57 thread2.start（）;
58 thread1.join（）;
59 thread2.join（）;
60 }
PipedReader/PipedWriter 示例
1 private static void communicationTest2（） throws InterruptedException， IOException
2 {
3 final PipedWriter pw = new PipedWriter（）;
4 final PipedReader pr = new PipedReader（pw）;
5 final BufferedWriter bw = new BufferedWriter（pw）;
6 final BufferedReader br = new BufferedReader（pr）;
7
8 Thread thread1 = new Thread（）
9 {
10 public void run（）
11 {
12
13 BufferedReader br = new BufferedReader（new InputStreamReader（System.in））;
14 try
15 {
16 while（true）
17 {
18 String message = br.readLine（）;
19 bw.write（message）;
20 bw.newLine（）;
21 bw.flush（）;
22 if （message.equals（end）） break;
23 }
24 br.close（）;
25 pw.close（）;
26 bw.close（）;
27 }
28 catch（Exception ex）
29 {
30 ex.printStackTrace（）;
31 }
32 }
33 };
34
35 Thread thread2 = new Thread（）
36 {
37 public void run（）
38 {
39
40 String line = null;
41 try
42 {
43 while（（line = br.readLine（）） != null）
44 {
45 System.out.println（line）;
46 if （line.equals（end）） break;
47 }
48 br.close（）;
49 pr.close（）;
50 }
51 catch（Exception ex）
52 {
53 ex.printStackTrace（）;
54 }
55 }
56 };
57
58 thread1.setDaemon（true）;
59 thread2.setDaemon（true）;
60 thread1.start（）;
61 thread2.start（）;
62 thread1.join（）;
63 thread2.join（）;
64 }
这篇文章就到这里，我们会鄙人一篇里，评论辩论同步的话题。
原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#
