黑马程序员--Java基础之多线程（2）

------------------
android培训、java培训、期待与您交流！ ---------------------
四、线程间通信---等待唤醒机制

1、线程间通信：就是多个线程在操作同一个资源，但是操作的动作不同。

如生产者和消费者的例子，比如轮流对人对象姓名年龄的输入和输出动作。

2、线程间的通信其实就是---不同动作间的同步问题！

操作同一资源的代码分别在不同的地方，要将他们同步在一起，并且还要轮流操作。

比如对人对象进行姓名年龄的输入和输出动作，输入动作和输出动作分别在不同的线程中，

而且这两个操作必须同步，还要轮流进行操作。

3、解决办法：使用同步Synchronized，用同一个锁使不同动作同步（可以使用要操作的同一个对象作为锁）。

使用flag标记位，通过判断标记位决定是否可以操作，结合wait方法等待，notify方法唤醒单个线程，

notifyAll方法唤醒所有等待的线程，实现不同动作的轮流操作。

wait(),notify(),notifyAll()方法必须使用在同步中，且必须拥有同步的锁。

4、示例代码：（轮流对人对象姓名年龄的输入和输出动作）

public class ThreadCommunication {

public static void main(String[] args) {
Person p = new Person();
Input in = new Input(p);//两个线程操作同一个对象，可以将该对象作为参数传入。
//也可以使用单例设计模式，但是太麻烦
Output out = new Output(p);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();

}

}
class Person{
private String name;
private String sex;
private boolean flag = false;

//设置姓名和性别的方法set
public synchronized void set(String name,String sex){
while(flag){//如果flag为true说明已经设置好姓名和性别，设置操作需要等待一下。
//如果flag为false说明设置的东西已经被取走，可以进行设置操作了,则继续往下走。
//这里使用while方法，不适用if方法，这是因为while循环使线程被唤醒时依然会判断一下标记！
try {this.wait();} catch (InterruptedException e){}//同步函数的锁是this
}
this.name = name;
this.sex = sex;

flag = true;//设置完毕，将标志位设置为true，表示已经设置完毕
this.notifyAll();//设置完毕唤醒其他线程
//this.notify();//notify()方法会造成死锁，因为它通常会唤醒线程池中第一个wait的方法。
}

//打印姓名和性别的方法get
public synchronized void get(){
while(!flag){
try {this.wait();} catch (InterruptedException e) {}
}
System.out.println(this.name+"-------------"+this.sex);

flag = false;
this.notifyAll();
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}

class Input implements Runnable{
private Person p;
private int x = 1;
Input(Person p){
this.p = p;
}
@Override
public void run() {
while(true){
if(x==1){
p.set("丽丽","女");
x++;
}
else{
p.set("John","man");
x--;
}
}
}
}

class Output implements Runnable{
private Person p;
Output(Person p){
this.p = p;
}
@Override
public void run() {
while(true){
p.get();
}
}
}

5、notify方法会造成死锁，
这是因为，等待的线程都按顺序存放在线程池中，notify通常唤醒线程池中的第一个线程，
也就是第一个wait的线程，这回造成死锁。notifyAll()方法用来解决死锁问题。但是对方线程会抢占资源。
6、JDK1.5改进：Lock：lock，unlock。 Condition，await，signal。显式的锁机制，以及显式的锁上的等待唤醒机制。
JDK1.5中提供了多线程升级解决方案，将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify，notifyAll 替换成了condition对象。可以通过Lock的锁，获取condition对象。

下面是多个生产者和消费者的代码示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProAndCon {
public static void main(String[] args){
Resource res = new Resource();
Producer pro = new Producer(res);
Consumer con = new Consumer(res);
Thread t1 = new Thread(pro);//制造多个生产者和消费者
Thread t2 = new Thread(pro);
Thread t3 = new Thread(pro);
Thread t4 = new Thread(con);
Thread t5 = new Thread(con);
Thread t6 = new Thread(con);

t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}

class Resource{
private int num;
private boolean flag = false;
private Lock lock = new ReentrantLock();//定义一个锁，它的锁和解锁操作代替了同步操作
private Condition pro_condition = lock.newCondition();//生产者的
private Condition con_condition = lock.newCondition();//消费者的

public void set(){
lock.lock();//首先上锁
try {
while(flag){
pro_condition.await();//如果有产品，生产者wait
}
++num;
System.out.println(Thread.currentThread().getName()+"生产的第"+num+"个产品");
flag = true;//生产后设置标记位为true
con_condition.signalAll();//唤醒所有消费者
} catch (InterruptedException e) {
}finally{
lock.unlock();//最后别忘了解锁，解锁放在finally语句中，确保一定会执行解锁
}
}

public void get(){
try {
lock.lock();
while(!flag){
con_condition.await();
}

System.out.println(Thread.currentThread().getName()+"消费了第+++++++++++"+num+"个产品+++++++++++");
flag = false;
pro_condition.signalAll();//唤醒所有生产者
} catch (InterruptedException e) {

}finally{
lock.unlock();
}
}

}

class Producer implements Runnable{
private Resource res ;
Producer(Resource res){
this.res = res;
}
@Override
public void run() {
while(true){
res.set();
}
}

}

class Consumer implements Runnable{
private Resource res;
Consumer(Resource res){
this.res = res;
}
@Override
public void run() {
while(true){
res.get();
}
}
}

五、停止线程、守护线程、线程优先级以及join方法yield方法

1、停止线程
stop()方法已经过时，一般代码运行完毕，该线程就结束了。
特殊情况：循环状态下，当线程处于冻结状态，就不会读取标记，也就不能结束线程。这时可以使用Thread类提供的方法 interrupt();对冻结清楚，然后修改标记，使循环结束。
2、守护线程
setDaemon (true)将该线程设置为守护线程。
守护线程又称后台线程，后台线程依赖于前台线程，前台线程只要一结束，后台线程也就随之结束。
注意：该方法必须在启动线程前调用。当正在运行的线程都是守护线程时，Java虚拟机退出,程序结束。
3、线程优先级
线程优先级共有是个级别：1-10 。
一般分为三个层次：MAX_PRIORITY(10);MIN_PRIORITY(1);NORM_PRIORITY(5)。
可以通过setPriority(int newPriority);来改变线程的优先级状态。
4、join方法，yield方法。
join()，等待该线程终止。当A线程执行到了B线程的join方法时，A就会等待，等B线程都执行完，A才会执行。
Join()可以用来临时加入线程执行。
yield(),暂停当前正在执行的线程对象，并执行其他线程。临时释放执行权，有利于线程的平均运行。