黑马程序员__java基础之线程间通信

------- android培训、java培训、期待与您交流！ ----------

线程间通信：

学习思路：
要实现线程间通信，首先要明确的明白通信之间如何连接。也就是说线程之间需要有共享的资源
那如何实现数据共享呢？
实现共享可以有3种方式：
（1）静态；（2）单例设计模式；（3）通过参数传递，这里通过构造函数实现
因为静态存在的时间过长，所以不建议。单例设计模式是允许的，这里的话，我们通过第三种方式进行讲解。

举例如下：

[java] view plain copy print ?

1. class ThreadTest
2. {
3. public static void main(String[] args)
4. {
5. Res r = new Res();
7. new Thread(new Input(r)).start();
8. new Thread(new Output(r)).start();
9. }
10. }
12. class Res
13. {

class ThreadTest
{
 public static void main(String[] args) 
 {
  Res r = new Res();

  new Thread(new Input(r)).start();
  new Thread(new Output(r)).start();
 }
}

class Res
{

[java] view plain copy print ?

1. /*
2. 优化前：
3. String name = name;
4. String sex = sex;
5. boolean flag =flag;
7. */
8. //优化后
9. private String name;
10. private String sex;
11. private boolean flag = false;
13. public synchronized void set(String name,String sex)
14. {
15. if(this.flag)
16. try{this.wait();}catch(Exception e){}
18. this.name = name;
19. this.sex = sex;
21. this.flag = true;
22. try{this.notify();}catch(Exception e){}
24. }
25. public synchronized void out()
26. {
27. if(!this.flag)
28. try{this.wait();}catch(Exception e){}
30. System.out.println(name+"…………"+sex);
31. this.flag = false;
32. try{this.notify();}catch(Exception e){}
33. }
34. }
36. class Input implements Runnable
37. {
38. private Res r;
39. Input(Res r)
40. {
41. this.r = r;
42. }
43. public void run()
44. {
45. int x = 0;
47. while(true) //为了实现连续多次打印，可以开始的用循环的形式进行输出
48. {
49. //给变量赋值
50. /*
51. 优化前的：
52. synchronized(r)
53. {
54. if(r.flag)
55. try{r.wait();}catch(Exception e){}
56. if(x == 0)
57. {
58. r.name = "mike";
59. r.sex = "man";
60. }
61. else
62. {
63. r.name = "丽丽";
64. r.sex = "女女女女女";
65. }
66. x = (x+1)%2;
67. r.flag = true;
68. r.notify();
69. }
70. */
71. //优化后
72. if(x==0)
73. r.set("mike","man");
74. else
75. r.set("丽丽","女女女女女");
76. x = (x+1)%2;
77. }
78. }
79. }
81. class Output implements Runnable
82. {
83. private Res r;
85. Output(Res r)
86. {
87. this.r = r;
88. }
89. public void run()
90. {
91. while(true)
92. {
93. //输出结果
94. /*优化前
95. synchronized(r)
96. {
97. if(!r.flag)
98. try{r.wait();}catch(Exception e){}
100. System.out.println(r.name+"…………"+r.sex);
101. r.flag = false;
103. try{r.notify();}catch(Exception e){}
104. }
105. */
106. //优化后
108. r.out();
110. }
111. }
112. }
113. /*

 /*
 优化前：
 String name = name;
 String sex = sex;
 boolean flag =flag;

 */
 //优化后
 private String name;
 private String sex;
 private boolean flag = false;

 public synchronized void set(String name,String sex)
 {
  if(this.flag)
   try{this.wait();}catch(Exception e){}

  this.name = name;
  this.sex = sex;

  this.flag = true;
   try{this.notify();}catch(Exception e){}

 }
 public synchronized void out()
 {
  if(!this.flag)
   try{this.wait();}catch(Exception e){}

  System.out.println(name+"…………"+sex);
  this.flag = false;
   try{this.notify();}catch(Exception e){}
 }
}

class Input implements Runnable
{
 private Res r;
 Input(Res r)
 {
  this.r = r;
 }
 public void run() 
 {
  int x = 0;

  while(true) //为了实现连续多次打印，可以开始的用循环的形式进行输出
  {
   //给变量赋值
   /*
   优化前的：
   synchronized(r)
   {
    if(r.flag)
     try{r.wait();}catch(Exception e){}
    if(x == 0)
    {
     r.name = "mike";
     r.sex = "man";
    }
    else
    {
     r.name = "丽丽";
     r.sex = "女女女女女";
    }
    x = (x+1)%2;
    r.flag = true;
    r.notify();
   }
   */
   //优化后
   if(x==0)
    r.set("mike","man");
   else
    r.set("丽丽","女女女女女");
   x = (x+1)%2;
  }
 }
}

class Output implements Runnable
{
 private Res r;

 Output(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  while(true)
  {
   //输出结果
   /*优化前
   synchronized(r)
   {
    if(!r.flag)
     try{r.wait();}catch(Exception e){}

    System.out.println(r.name+"…………"+r.sex);
    r.flag = false;

    try{r.notify();}catch(Exception e){}
   }
   */
   //优化后
   
   r.out();

  }
 }
}
/*

按上面的输出结果出现"mike 女女女女""丽丽 man"的情况，出现安全问题;
当出现安全问题的时候，首先要分析为什么会这样输出，什么原因呢？显然，这是由于输入输出不同步造成的
即输出的时候还进行到一半的时候，设置的值已经改变。因此，要解决这个问题，我们要做的，就是使
输入输出同步！注意，是输入输出都要同步,而不是其中之一同步。这点要注意。
同步时要注意，为了保证使用同一把锁，要把同步代码块的锁，使用同一对象。这里可以使用r。

完成以上步骤后，就实现了同步。但是有一个问题就是输入输出时总是连续的输出相同的，而我们想要的是：
输入一个，输出一个。为了达到这个目的，我们可以通过使用标记的方式。
开始的时候，我们可以初始化标记为false，如果开始的时候为真，则等待。假的话，就设置值。
当设置完后，标记的flag的真假要改变。顺便说一下，等待多线程放在线程池里，唤醒的时候（notify），
一定要指明唤醒的对象，最先唤醒的，是最近要执行的那一个!任意对象只能被同一对象的锁唤醒。
代码：

因为notify，wai方法哪个都可以调用，所以为Object类型。因为在run方法中，不能抛，只能解决

对程序优化后（见上面优化后代码）

这个线程是输入输出只有一个的情况，而现实中多是多个线程同时运行，这就是生产者消费者问题：

[java] view plain copy print ?

1. class ProductConsumerDemo
2. {
3. public static void main(String[] args)
4. {
5. Resource r = new Resource();
7. new Thread(new Producer(r)).start();
8. new Thread(new Producer(r)).start();
9. new Thread(new Consumer(r)).start();
10. new Thread(new Consumer(r)).start();
12. //创建并启动线程
13. }
14. }
15. class Resource
16. {
17. private String name;
18. private int count = 1;
19. private boolean flag;
21. //生产商品
22. public synchronized void set(String name)
23. {
24. /*
25. 优化前：
26. if(flag)
27. */
28. //优化后
29. while(flag)
30. try{this.wait();}catch(Exception e){}
31. this.name = name+"--"+count++;
32. System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
33. flag = true;
34. /*
35. 优化前：
36. try{this.notify();}catch(Exception e){}
37. */
38. //优化后：
39. try{this.notifyAll();}catch(Exception e){}
41. }
43. public synchronized void out()
44. {
45. /*
46. 优化前：
47. if(!flag)
48. */
49. //优化后
50. while(!flag)
51. try{this.wait();}catch(Exception e){}
52. System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
53. flag = false;
54. try{this.notify();}catch(Exception e){}
55. }
57. }
58. //生产者
59. class Producer implements Runnable
60. {
61. private Resource res;
63. Producer(Resource res)
64. {
65. this.res = res;
66. }
67. public void run()
68. {
69. while(true)
70. {
71. res.set("商品");
72. }
73. }
74. }
76. //消费者
77. class Consumer implements Runnable
78. {
79. private Resource con;
81. Consumer(Resource con)
82. {
83. this.con = con;
84. }
85. public void run()
86. {
87. while(true)
88. con.out();
89. }
90. }

class ProductConsumerDemo
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		new Thread(new Producer(r)).start();
		new Thread(new Producer(r)).start();
		new Thread(new Consumer(r)).start();
		new Thread(new Consumer(r)).start();

		//创建并启动线程
	}
}
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag;

	//生产商品
	public synchronized void set(String name)
	{
		/*
		优化前：
		if(flag)
		*/
		//优化后
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name+"--"+count++;
		System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
		flag = true;
		/*
		优化前：
		try{this.notify();}catch(Exception e){}
		*/
		//优化后：
		try{this.notifyAll();}catch(Exception e){}

	}

	public synchronized void out()
	{
		/*
		优化前：
		if(!flag)
		*/
		//优化后
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
		flag = false;
		try{this.notify();}catch(Exception e){}
	}
	
}
//生产者
class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.set("商品");
		}
	}
}

//消费者
class Consumer implements Runnable
{
	private Resource con;

	Consumer(Resource con)
	{
		this.con = con;
	}
	public void run()
	{
		while(true)
			con.out();
	}
}

但是按上面的代码操作时，会出现安全问题。这是因为当多个线程同时运行时，原来的等待唤醒机制出现局限性
因为notify在唤醒的过程中，只唤醒线程池中当前最近要执行的那个线程，如生产者t1,t2,当某一次刚好执行完t1
时，线程t2也处于唤醒状态，而t1在判断完后，刚好处于wait状态，而t2运行后，则不再判断flag的真假性，
这个是引起问题原因之一，如果把if改为while之后，因为notify就出现局限性，导致所有的线程进入等待状态。
要使程序继续执行，则需要用notifyAll方法，改动部分，如下代码：

[java] view plain copy print ?

1. //生产商品
2. public synchronized void set(String name)
3. {
4. //优化前：
5. //if(flag)
7. //优化后
8. while(flag)
9. try{this.wait();}catch(Exception e){}
10. this.name = name+"--"+count++;
11. System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
12. flag = true;
14. //优化前：
15. //try{this.notify();}catch(Exception e){}
17. //优化后：
18. try{this.notifyAll();}catch(Exception e){}
20. }
22. public synchronized void out()
23. {
25. //优化前：
26. //if(!flag)
28. //优化后
29. while(!flag)
30. try{this.wait();}catch(Exception e){}
31. System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
32. flag = false;
33. try{this.notify();}catch(Exception e){}
34. }

//生产商品
 public synchronized void set(String name)
 {
  //优化前：
  //if(flag)
  
  //优化后
  while(flag)
   try{this.wait();}catch(Exception e){}
  this.name = name+"--"+count++;
  System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
  flag = true;
  
  //优化前：
  //try{this.notify();}catch(Exception e){}
  
  //优化后：
  try{this.notifyAll();}catch(Exception e){}

 }

 public synchronized void out()
 {
  
  //优化前：
  //if(!flag)
  
  //优化后
  while(!flag)
   try{this.wait();}catch(Exception e){}
  System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
  flag = false;
  try{this.notify();}catch(Exception e){}
 }
 

在这个程序中，notifyAll会同时唤醒本方和对象的线程，那是否可以直接唤醒对方的线程呢？
jdk 5.0之后，对这个问题进行了解决，出现了新的加锁解锁机制。
加锁--解锁：lock---unlock；
对象唤醒机制
condition.await();condition.signal();
将上上述代码转化为升级后的代码为：

[java] view plain copy print ?

2. //Jdk 1.5升级后，生产消费者问题
4. import java.util.concurrent.locks.*;
6. class ProductConsumerDemo2
7. {
8. public static void main(String[] args)
9. {
10. Resource r = new Resource();
12. //创建并启动线程
13. new Thread(new Producer(r)).start();
14. new Thread(new Producer(r)).start();
15. new Thread(new Consumer(r)).start();
16. new Thread(new Consumer(r)).start();
19. }
20. }
21. class Resource
22. {
23. private String name;
24. private int count = 1;
25. private boolean flag;
27. //创建使用锁对象
28. private Lock lock = new ReentrantLock();
29. private Condition condition_pro = lock.newCondition();
30. private Condition condition_con = lock.newCondition();
32. //生产商品
33. public void set(String name)throws InterruptedException
34. {
35. //加锁
36. lock.lock();
37. try
38. {
39. while(flag)
40. condition_pro.await();
41. this.name = name+"--"+count++;
43. System.out.println(Thread.currentThread().getName()+"生产者---"+this.name);
44. flag = true;
45. condition_con.signal();
46. }
47. finally
48. {
49. lock.unlock(); //解锁
50. }
52. }
54. public void out()throws InterruptedException
55. {
56. lock.lock();
57. try
58. {
59. while(!flag)
60. condition_con.await();
61. System.out.println(Thread.currentThread().getName()+"消费者-------------"+this.name);
62. flag = false;
63. condition_pro.signal();
64. }
65. finally
66. {
67. lock.unlock(); //解锁
68. }
69. }
71. }
72. //生产者
73. class Producer implements Runnable
74. {
75. private Resource res;
77. Producer(Resource res)
78. {
79. this.res = res;
80. }
81. public void run()
82. {
84. while(true)
85. {
86. try
87. {
88. res.set("商品");
89. }
90. catch (InterruptedException e)
91. {
92. }
94. }
96. }
97. }
99. //消费者
100. class Consumer implements Runnable
101. {
102. private Resource con;
104. Consumer(Resource con)
105. {
106. this.con = con;
107. }
108. public void run()
109. {
110. while(true)
111. {
112. try
113. {
114. con.out();
115. }
116. catch (InterruptedException e)
117. {
118. }
119. }
120. }
121. }

 
//Jdk 1.5升级后，生产消费者问题

import java.util.concurrent.locks.*;

class ProductConsumerDemo2
{
 public static void main(String[] args) 
 {
  Resource r = new Resource();
  
  //创建并启动线程
  new Thread(new Producer(r)).start();
  new Thread(new Producer(r)).start();
  new Thread(new Consumer(r)).start();
  new Thread(new Consumer(r)).start();

  
 }
}
class Resource
{
 private String name;
 private int count = 1;
 private boolean flag;

 //创建使用锁对象
 private Lock lock = new ReentrantLock();
 private Condition condition_pro = lock.newCondition();
 private Condition condition_con = lock.newCondition();

 //生产商品
 public void set(String name)throws InterruptedException
 {
  //加锁
  lock.lock();
  try
  {
   while(flag)
    condition_pro.await();
   this.name = name+"--"+count++;

   System.out.println(Thread.currentThread().getName()+"生产者---"+this.name);
   flag = true;
   condition_con.signal();
  }
  finally
  {
   lock.unlock(); //解锁
  }
  
 }

 public void out()throws InterruptedException
 {
  lock.lock();
  try
  {
   while(!flag)
    condition_con.await();
   System.out.println(Thread.currentThread().getName()+"消费者-------------"+this.name);
   flag = false;
   condition_pro.signal();
  }
  finally
  {
   lock.unlock(); //解锁
  }
 }
 
}
//生产者
class Producer implements Runnable
{
 private Resource res;

 Producer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  
  while(true)
  {
   try
   {
    res.set("商品");
   }
   catch (InterruptedException e)
   {
   }
   
  }
  
 }
}

//消费者
class Consumer implements Runnable
{
 private Resource con;

 Consumer(Resource con)
 {
  this.con = con;
 }
 public void run()
 {
  while(true)
  {
   try
   {
    con.out();
   }
   catch (InterruptedException e)
   {
   }
  }
 }
}

jdk1.5版本以后，对锁机制的改正在于使用lock与unlock方法，使加锁解锁更直观；
同时，使用Condition接口子类的方式，在lock接口的子类中可以使用多个Condition接口子类对象，
可以使本方对象唤醒对方。而原来一个同步只能一个对象，多个对象嵌套的话，容易造成死锁。改正后就
避免了这个问题。

在上面对线程操作后，我们都是通过直接在控制台上使用ctrl+c强制结束，那到底该怎么结束运行的线程呢？
在java中只有一种方式，那就是使run中的方法运行结束。结束的关键就是控制循环条件。
如下所示：

[java] view plain copy print ?

1. class StopThreadDemo
2. {
3. public static void main(String[] args)
4. {
5. StopThread t = new StopThread();
7. Thread t1 = new Thread(t);
8. Thread t2 = new Thread(t);
10. t1.start();
11. t2.start();
13. int num = 0;
15. while(true)
16. {
17. if(num++ == 60)
18. {
19. t.changeFlag();
20. break;
21. }
22. System.out.println(Thread.currentThread().getName()+"………………"+num);
23. }
24. }
25. }
27. class StopThread implements Runnable
28. {
29. private boolean flag = true;
31. public void run()
32. {
33. while(flag)
34. System.out.println(Thread.currentThread().getName()+"………………Thread run");
35. }
37. public void changeFlag()
38. {
39. flag = false;
40. }
41. }

class StopThreadDemo 
{
 public static void main(String[] args) 
 {
  StopThread t = new StopThread();

  Thread t1 = new Thread(t);
  Thread t2 = new Thread(t);

  t1.start();
  t2.start();

  int num = 0;

  while(true)
  {
   if(num++ == 60)
   {
    t.changeFlag();
    break;
   }
   System.out.println(Thread.currentThread().getName()+"………………"+num);
  }
 }
}

class StopThread implements Runnable
{
 private boolean flag = true;

 public void run()
 {
  while(flag)
   System.out.println(Thread.currentThread().getName()+"………………Thread run");
 }

 public void changeFlag()
 {
  flag = false;
 }
}

但是，还有一种情况，就是当多个运行时,如果都处于等待状态，可以使用Thread类的interrupt方法停止
等待状态，使程序继续运行。只是都会抛出异常（注意抛出异常是wait出现异常，而不是中断位置出现
异常），代码如下：

[java] view plain copy print ?

1. class StopThreadDemo
2. {
3. public static void main(String[] args)
4. {
5. StopThread t = new StopThread();
7. Thread t1 = new Thread(t);
8. Thread t2 = new Thread(t);
10. t1.start();
11. t2.start();
13. int num = 0;
15. while(true)
16. {
17. if(num++ == 60)
18. {
19. //t.changeFlag();
20. t1.interrupt();
21. t2.interrupt();
22. break;
23. }
24. System.out.println(Thread.currentThread().getName()+"………………"+num);
25. }
26. }
27. }
29. class StopThread implements Runnable
30. {
31. private boolean flag = true;
33. public synchronized void run()
34. {
35. while(flag)
36. {
37. try
38. {
39. wait();
40. }
41. catch (InterruptedException e)
42. {
43. System.out.println(Thread.currentThread().getName()+"………………Exception");
44. flag = false;
45. }
46. System.out.println(Thread.currentThread().getName()+"………………Thread run");
47. }
48. }
50. public void changeFlag()
51. {
52. flag = false;
53. }
54. }

class StopThreadDemo 
{
 public static void main(String[] args) 
 {
  StopThread t = new StopThread();

  Thread t1 = new Thread(t);
  Thread t2 = new Thread(t);

  t1.start();
  t2.start();

  int num = 0;

  while(true)
  {
   if(num++ == 60)
   {
    //t.changeFlag();
    t1.interrupt();
    t2.interrupt();
    break;
   }
   System.out.println(Thread.currentThread().getName()+"………………"+num);
  }
 }
}

class StopThread implements Runnable
{
 private boolean flag = true;

 public synchronized void run()
 {
  while(flag)
  {
   try
   {
    wait();
   }
   catch (InterruptedException e)
   {
    System.out.println(Thread.currentThread().getName()+"………………Exception");
    flag = false;
   }
   System.out.println(Thread.currentThread().getName()+"………………Thread run");
  }
 }

 public void changeFlag()
 {
  flag = false;
 }
}

另外，在多线程中还有这样的方法setDaemo()，守护线程，也可以理解为后台线程。这个线程特点是：
守护的对象结束，这些守护线程也就结束了。如我们可以把上面的interrupt或者同时也把wait取消，
只要把t1，t2，设置为主线程的守护线程，主线程结束，守护线程也就自动停止。

多线程中还有一个join方法，该方法的特点是：直接向cpu索要执行权，如果join在主线程中，那么主线程要
等待该调用join的线程结束，主线程才会执行。
toString在多线程输出有所不同，格式是线程名称，所属线程。setPriority()方法可以设置线程的优先级。
Thread还有yield方法停止当前线程，运行其他线程。

多线程总结（最优选择）：
在多线程安全问题控制方面，选择的是lock接口与Condition接口的子类对象，这样可以实现同一把锁，使用
多把锁，因此在唤醒的时候可以直接唤醒对方的线程，在一定程度上也避免了死锁等情况的发生频率。
线程的结束的话，一种方法是通过控制循环条件，让线程自己运行完结束。或者通过"线程名.interrupt()"调用
结束。
此外，还有一种是通过守护线程的形式，当被守护的线程结束，守护线程也就结束了。
如果使用join方法的话，如果在主线程中执行，则必须等调用join的线程执行完，主线程才会执行。
toString方法和setPriority（）以及yield方法也是需要注意的对象。