多线程--线程间通信
对同一个资源进行处理，但是任务却不同
线程间通信--等待唤醒机制
1、wait(); 线程处于冻结状态，被wait线程存储在线程池中
2、notify(); 从线程池唤醒一个线程
3、notifyAll(); 唤醒所有线程
方法必须定义在同步中
为什么操作线程的方法wait notify notifyAll定义在Object类中
因为这些方法是监视器的方法，监视器其实就是锁
锁可以是任意的对象，任意的对象调用的方式一定是定义在Object类中
唤醒--代码优化
多生产者多消费者
多生产多消费者问题解决
notifyAll();
while判断标记，解决了线程获取执行权后是否重新运行
notifyAll()解决了本方线程一定唤醒对方线程
多生产多消费问题 JDK1.5新特性 -- Lock
同步代码块，对于锁的操作是隐式的。
import java.util.concurrent.locks.*;
//import java.util.condition;
class Resource{
private String name;
private int count = 1;
private boolean flag = false;
Lock lock = new ReentrantLock();
//Condition c1 = lock.newCondition();
Condition pro_con = lock.newCondition();
Condition cos_con = lock.newCondition(); Resource(){} public void set(String name){//synchronized
lock.lock();
try{
while(flag)//while(flag)--死锁
//try{wait();}catch(InterruptedException e){}
try{pro_con.await();}catch(InterruptedException e){}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName()+": 生产..5.0. "+this.name);
flag = true;
//notifyAll();//notifyAll()
//c1.signalAll();//notifyAll()
cos_con.signal();//notifyAll()
}
finally{
lock.unlock();
} } public void out(){ //synchronized
lock.lock();
try{
while(!flag)//while(flag)--出现死锁--notifyAll()
try{cos_con.await();}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+":...消费了......"+name);
flag = false;
//notifyAll();//notifyAll()}
//c1.signalAll();
pro_con.signal(); }
finally{
lock.unlock();//notifyAll()
}
}
} class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r = r;
} public void run(){
while(true){
r.set("烤鸭");
} }
} class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r = r;
}
public void run(){
while(true){
r.out();
}
}
} class ProduceConsumerDemo{
public static void main(String[] args){
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r); Thread t0 = new Thread(pro);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(con); t0.start();
t1.start();
t2.start();
t3.start(); }
}
将同步和锁封装成了对象
JDK1.5新特性--condition
wait notify notifyAll
JDK1.5解决方法
一个锁多个监视器
范例
Lock 接口：替代了同步代码块或同步函数，由隐式锁操作变成显示
lock() 获取锁
unlock() 释放锁 在finally代码块中
Condition 接口 替代了Object中的wait notify notifyAll方法，单独进行封装
await
signal
signalAll
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
wait sleep 区别
1、wait可以指定时间也可以不指定，sleep必须指定
2、在同步中，对cpu的执行权和锁的处理不同
wait 释放执行权和锁
sleep 释放执行权 不是释放锁
停止线程方式--定义标记
1、stop方法
2、run方法结束
怎么控制线程的任务结束呢？
控制循环就可以结束任务
停止线程方式--Interrupt
如果线程处于冻结状态，无法读取标记，如何结束？
interrupt 将线程从冻结强制恢复成运行状态，但会发生中断异常
守护进程--setDaemon
后台线程，先于线程启动前调用
join方法
setPriority(Thread.MAX_PRIORITY)
yield