黑马程序员_九 【线程间通信】【等待唤醒机制】【JDK1.5线程新特性】【其他知识点】

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

1 线程间的通信

线程间的通信，其实就是多个线程在操作同一个资源，但是操作的动作不同，需要有相互的配合。
代码演示：
class Res//定义一个类，用来存放name和sex的值。之所以不放在下面的类中，是因为下面有两个类分别为输入和输出，把对象放在一个类中方便调用
{
String name;
String sex;
}
class Inputimplements Runnable
{
private Res r ;//私有化Res的对象r，只让内部调用
Input(Res r)
{
this.r = r;//将input对象中r的值赋值给本类Res中的对象r
}
public void run()//覆写run函数，方便实现多线程。
{
int x = 0;
while(true)
{
if(x==0)//当x=0时执行if语句
{
r.name="mike";//赋值name和sex
r.sex="man";
}
else
{
r.name="丽丽";//否则当x不等于0时，在赋值name和sex
r.sex = "女女女女女";
}
x = (x+1)%2;//程序运行完了执行这个，x+1在取模2，1%1结果是1，2%2是0，这样就会让语句继续循环if和else
}
}
}
}
class Outputimplements Runnable//实现Runnable接口，方便建立多线程
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
System.out.println(r.name+"...."+r.sex);
}
}
}
class InputOutputDemo
{
public static void main(String[] args)
{
Res r = new Res();//建立Res的对象r。
Input in = new Input(r);//建立input的对象in，input的对象为r，这样每次调用in都会执行input（Res r）这个构造函数。
Output out = new Output(r);//建立output的对象out，output的对象为r，这样每次调用out都会执行output（Res r）这个构造函数。
Thread t1 = new Thread(in);//建立一个多线程t1，线程中的执行对象为in
Thread t2 = new Thread(out);
t1.start();//通过新建立的线程，执行in中的代码~
t2.start();
}
}
通过上面的代码可以发现结果如下
为什么出现mike是女，丽丽是man的情况呢？
答案是多线程，当input存mike的时候，output就拿到了执行权，输出了mike，但是性别没有输出，再输入性别man的时候，如果output没有拿到执行权，是不会输出man的，当sex输入女女的时候，output拿到执行权，这时输出的就是mike…女女
该如何解决？
可以用synchonized，但是如果直接修饰run函数，就会变成了单线程，input和output就没意义了。不如直接用主线程运行。
解决代码
class Res
{
String name;
String sex;
boolean flag = false;
}

class Inputimplements Runnable
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
synchronized(r)//用synchonized将if中的函数锁上，这样就可以了。但是如果只锁这一个if函数，输出的结果还是错误的，原因是？看多线程同步的前提第一个，必须是多线程。这个锁锁住的只是其中一个线程，想要同时锁住input和output还要在输出语句上加锁
{

if(r.flag)
try{r.wait();}catch(Exceptione){}
if(x==0)
{
r.name="mike";
r.sex="man";
}
else
{
r.name="丽丽";
r.sex = "女女女女女";
}
x = (x+1)%2;
r.flag = true;
r.notify();
}
}
}
}

class Outputimplements Runnable
{
private Res r ;

Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r)//这里加个锁，按理说应该锁住了，但是实际情况仍然是输出错误。因为两个锁没有连在一起。如果对象是obj的话，不唯一，没法连在一起。如果括号内的对象为一个一唯一类就行了。譬如input。Class，output。class，为了方便，直接用r就行了。
{
if(!r.flag)
try{r.wait();}catch(Exceptione){}
System.out.println(r.name+"...."+r.sex);
r.flag = false;
r.notify();
}
}
}
}
2 等待唤醒机制

class Res
{
String name;
String sex;
boolean flag = false;//定义boolean型函数flag为false
}
class Inputimplements Runnable
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
synchronized(r)
{
if(r.flag)//如果flag为真则执行wait()语句，否则向下继续执行
try{r.wait();}catch(Exceptione){}
if(x==0)
{
r.name="mike";
r.sex="man";
}
else
{
r.name="丽丽";
r.sex = "女女女女女";
}
x = (x+1)%2;//x=0就输出man，不为0就输出女
r.flag = true;//输入完了已经把flag就变为true，这样做就像一个小开关，关上了输入语句，方便执行输出语句。
r.notify();//notify()语句，意思是唤醒对象r的睡眠函数。
}
}
}
}
class Outputimplements Runnable
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r)
{
if(!r.flag)//当flag不为true的时候，执行wait()语句，将线程进入sleep状态，就不会输出。因为上面输入完成以后，flag为true了，所以直接打印刚刚输入的名字和sex。
try{r.wait();}catch(Exceptione){}
System.out.println(r.name+"...."+r.sex);
r.flag = false;//输出完了以后再将flag改为false，方便输入下一个name和sex
r.notify();//再次唤醒，每次唤醒都是一次判定，唤醒的时候flag为true就执行输入，为false就执行输出语句。而且每次输入完了，x自动取模，这样可以方便下次输入另一个性别
}
}
}
}
注意：通过API查找发现wai()notify()notifyall()都必须在锁内部才能使用，而且使用的时候，得标注对象。如r.wait().如果不标注会混淆。
Wait();
notify();
notifyAll();
都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。
问题：为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。（两个synchronized(r)的对象都是r，是同一个锁）
而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
经典案例：
生产者消费者
class Demo
{
public static void main(String[] args)
{
Resource r = new Resource();//建立Resource对象r
Producer pro = new Producer(r);//建立生产者对象pro为new Producer(r)的对象。调用对象就执行Producer(r)的构造函数。
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);//建立4个线程，2个生产的
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);//2个消费的
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();//运行4个线程
}
}
class Resource//这个类用来放同步函数
{
private String name;
private int count = 1;//利用count记录每次生产和消费，方便检验
private boolean flag = false;//初始化布尔型flag值为false
public synchronized void set(Stringname)//建立public同步函数，set(String name)，作用是输入名字
{
while(flag)//判断flag如果为true，就执行下面的语句。
try{this.wait();}catch(Exceptione){}//如果上面不用while，用if，当if true的时候，线程会执行wait（），这个时候线程会卡在这个地方。而用while的话，当为true的时候才执行wait()，重复这条语句就执行完了，不会卡在这里，唤醒的时候会再次判断flag。
this.name =name+"--"+count++;//将set函数的名字赋值给本类成员函数name，便于out函数使用，并且用count自加来记录
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);//输出线程的名字和生产者还有set对象的名字
flag = true;//让flag转换为true，让该线程直接输出。
this.notifyAll();//唤醒所以的线程，而不是只唤醒一个线程，这样的话，利用flag判断就可以是输入的线程停止，输出的线程开始
}
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exceptione){}
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notifyAll();
}
}
class Producerimplements Runnable//生产者函数，实现runnable，可以实现多线程
{
private Resource res;//私有res，为Resource的对象
Producer(Resource res)//构造函数，对象为Resource的res
{
this.res = res;//将构造函数中的res赋值给成员函数res
}
public void run()//多线程函数必须覆盖runnable里面的run函数
{
while(true)//当为true的时候，执行下面的代码
{
res.set("+商品+");//输入商品这个字符串
}
}
}
class Consumerimplements Runnable//消费者函数，实现runnable，可以实现多线程
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();//执行res的out函数。
}
}
}
对于多个生产者和消费者。为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
详细流程：
t1t2t3t4一起运行，当t1先抢到执行权的时候，输出，生产者。。商品、、生产者。flag为false，唤醒本同步函数，再次执行，t1判断，wait（）。假设t2进来了，也wait（），t1t2都进入sleep状态。假设t3进来，执行输出语句。然后再次改变flag，为true，再次唤醒，如果用notify唤醒，只唤醒最早的那个，就是t1。此时剩下运行状态的只有t4和t1，假设t4进来了，又wait（）了，t1再进来，执行输出语句。falg为false，再次唤醒。notify只唤醒最早沉睡的，所以只有t2醒了，但是t2如果用if的话只能继续执行了，输出的结果会有两个生产者商品生产。所以必须用while语句。但是只用while语句解决了判断问题，如果t2执行判断又是true，那么4个线程就都沉睡了。所以要要用notifyall语句。
3 JDK1.5新特性Lock

JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
lock
unlock
newCondition()

Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();
代码演示：
importjava.util.concurrent.locks.*;
classProducerConsumerDemo2
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
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();//t1,t2
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 Producerimplements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("+商品+");
}
catch (InterruptedException e)
{
}
}
}
}
class Consumerimplements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}
4 线程的终止

问题：如何停止线程？
如何停止线程？
只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。
特殊情况：
当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。（如同步函数中遇到了wait()）
当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。
Thread类提供该方法 interrupt();
例子：
class StopThreadimplements Runnable
{
private boolean flag =true;//私有一个布尔flag为true
public void run()//覆盖run函数,用来建立多线程
{
while(flag)//判断当flag为true时才执行以下语句
{
System.out.println(Thread.currentThread().getName()+"....run");//输出的是线程名称和run
}
}
public void changeFlag()
{
flag = false;//改变flag的函数代码
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st = new StopThread();//建立st函数为new StopThread()的对象
Thread t1 = new Thread(st);//建立一个t1的线程，该线程执行的是st里的内容
Thread t2 = new Thread(st);//建立一个t2的线程
t1.start();//执行t1线程
t2.start();
int num = 0;//成员变量num
while(true)//当为true的时候
{
if(num++ == 60)//num自加以后为60，就执行下面的函数
{
//st.changeFlag();这个函数用来转换flag的值，转换以后
//t1.interrupt();
//t2.interrupt();
break;//停止程序，并跳出
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("over");
}
}
5 其他知识点

|--守护线程

setDaemon()，守护线程，将线程设置成主函数的守护线程，当主函数停止时，他也跟着停止，如t2.setDaemon(true)
public finalvoid setDaemon(boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。
|--join方法

Jion 等待该线程终止。这个函数的意思是主线程main释放执行权（注意，使用这个会在函数中抛出InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。）
如 t1.start();
t1.join();
t2.start();
执行上面的指令，遇到t1.join();主函数释放执行权，这时候会等待t1执行完才继续行驶执行权。如果t1.start();
t2.start();
t1.join();
当主函数遇到t1.join();的时候，释放执行权，但是这时候t1和t2都在抢夺执行权，所以会交互执行，直到t1执行完了，main主线程才有执行权，会和t2继续交叉执行
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
假如B线程进入睡眠状态了，那么会抛出InterruptedException，当抛出该异常时，当前线程的中断状态 被清除，继续执行A线程。
join可以用来临时加入线程执行。
线程的优先级
t1.setPriority(Thread.MAX_PRIORITY);
setPriority更改线程的优先级。 public final void setPriority(intnewPriority)
更改后当前线程可以具有相应的优先级。
MAX_PRIORITY线程可以具有的最高优先级
MIN_PRIORITY线程可以具有的最低优先级。
NORM_PRIORITY分配给线程的默认优先级。
凡是固定值，就定义成常量，凡是共享数据，就定义成静态
|--Thread.yield() 方法

public staticvoid yield()
暂停当前正在执行的线程对象，并执行其他线程。意思是临时释放执行权
|--toString()方法

public String toString()
返回该线程的字符串表示形式，包括线程名称、优先级和线程组。返回值位该线程该线程的字符串表示形式。如
Thread.currentThread().toString()

例子：
class ThreadTest
{
public static void main(String[] args)
{

new Thread()//匿名thread函数的调用
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}.start();//调用匿名函数中的start()，执行多线程函数

for(int x=0; x<100; x++)//三个线程，这个是主函数
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}

Runnable r = newRunnable()//建立一个runnable的对象r，因为runnable是个接口，不能调用，只能通过建立对象实现
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
};
new Thread(r).start();匿名函数调用对象r中的start()
}
}

本篇博文和上篇博文记录了多线程的知识点。多线程在陈旭开发中有很大的作用，特别是现在多核cpu时代的到来，显得更加重要，可以有效地利用其cpu的资源，把计算机的性能发挥的更好。

本篇博文结束！

@感谢老师的辛苦批阅