---------------------------------------- android培训、java培训、期待与您交流! ------------------------------------
线程间通讯:
多个线程在处理同一资源,但是任务却不同;
一:wait() notify() notifyAll()用来操作线程的,定义在Object类中
1.这些方法存在同步中
2.使用这些方法必须要标示所属的同步锁
3.这些都是监视器的方法,监视器其实就是锁,锁可以是任意对象,任意的对象调用的方式一定定义在Object中。
二:wait和sleep的区别
都会抛出异常,需要处理,都会使线程进入冻结状态
1.wait():释放资源,释放锁,需要被notify()唤醒。
2.sleep():释放资源,不释放锁,休息一段时间醒来后继续执行。
3.yield():释放锁,使当前线程马上回到就绪状态,也可以马上执行。
暂停当前正在执行的线程,并执行其他线程
在同步代码块中,只要有特有对象都可以作为同步锁,因为要保证锁的唯一性。
等待唤醒机制
使用标记flag,使生产线程和消费线程交替执行并执行完毕后唤醒对方
单一同步只能保证对象属性的正确,不能保证输入与输出一对一,加入等待唤醒后才能够实现单输入与单输出一对一,但不能解决多输入多输出的协调。
单生产和单消费实例:
package thread;
public class ProducerConsumer {
public static void main(String[] args) {
//创建资源对象
Resource r = new Resource();
Producer producer = new Producer(r);
Consumer consumer = new Consumer(r);
Thread t = new Thread(producer);
Thread t2 = new Thread(consumer);
t.start();
t2.start();
}
}
class Resource {
private String name;//要生产的东西的名字
private int count = 1;//初始值为1
private boolean flag = false;//默认为没有
public synchronized void set(String name) {
// 如果有馒头就进入等待状态,通知消费者来吃
if (flag) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//如果flag = flase就生产馒头
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName() + ".....生产者....."
+ this.name);
//生产完后设置flag为true,则自己进入等待状态,然后唤醒对方起来吃
flag = true;
this.notifyAll();
}
public synchronized void out() {
// 如果没有馒头就等待
if (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//flag等于true等于有馒头,我们就起来吃
System.out.println(Thread.currentThread().getName()
+ "..........消费者..........." + this.name);
//吃完设置flag = false,自己进入等待状态,唤醒消费者,等馒头出来了在起来吃。
flag = false;
this.notify();
}
}
class Producer implements Runnable {
private Resource r;
public Producer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.set("馒头");
}
}
}
class Consumer implements Runnable {
private Resource r;
public Consumer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.out();
}
}
}
多生产者 多消费者的问题
while...notifyAll()
相对于单生产单消费的问题,多生产多消费的情况会每次notify()唤醒的线程都不确定,有可能是本方也有可能是对方,会发生 冻结状态导致的不同步,不能对应输出
所以每次线程被唤醒后执行时都要对标记进行判断,如果唤醒的是本方线程,由于标记未改变仍然不能执行。从而保证双方线程交替执行
但是使用while标记判断如果只随机notify()随机唤醒了一个线程,一旦唤醒的是本方线程,就会导致线程全部处于临时阻塞状态(没有了执行权),所以使用while时要使用notifyAll()
示例:
while(flag)//标记判断
try{this.wait();}
catch (Exception e){
}
要执行的程序方法体;
flag = true;//改变标记
this.notifyAll();//唤醒全部
JDK5.0新增的两个接口
功能更加强大的锁,更加直观的显式锁,将锁进行的对象的封装,并且将锁的操作也封装成对象。
lock接口替代synchronized同步锁,
Condition接口替代Object监视器方法
wait() notify() notifyAll()
await() signal() signalAll()
从Lock 创建锁从lock接口的方法newCondition()获取实例来操作锁,Lock的强大之处在于能够获取多个实例来操作同一个锁,可以用来对指定任务进行控制。
await() 或者signal()对方(指定的任务),不用唤醒全部,本方只唤醒对方
private Lock lock = new ReentrantLock();// 创建锁
private Condition condition_pro = lock.newCondition();// 通过锁获取Condition实例
private Condition condition_con = lock.newCondition();// 一锁多用,相互唤醒
多生产多消费升级方案:
package thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Resource1 {
private Lock lock = new ReentrantLock();// 创建锁
private Condition condition_pro = lock.newCondition();// 通过锁获取Condition实例
private Condition condition_con = lock.newCondition();// 一锁多用,相互唤醒
private String name;
private int count = 1;
private boolean flag = false;
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,欢迎消费者。
flag = true;
condition_con.signal();// 这样的结构清晰多了
} finally {
lock.unlock();// 在finally中施放锁
}
}
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 Producer1 implements Runnable {
private Resource1 r;
public Producer1(Resource1 r) {
super();
this.r = r;
}
@Override
public void run() {
while (true) {
try {
r.set("包子");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class Consumer1 implements Runnable {
private Resource1 r;
public Consumer1(Resource1 r) {
super();
this.r = r;
}
public Resource1 getR() {
return r;
}
public void setR(Resource1 r) {
this.r = r;
}
@Override
public void run() {
while (true) {
try {
r.out();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class ProducerConsumerDemo {
public static void main(String[] args) {
Resource1 r = new Resource1();
Producer1 producer = new Producer1(r);
Consumer1 consumer = new Consumer1(r);
Thread t = new Thread(producer);
Thread t2 = new Thread(producer);
Thread t3 = new Thread(consumer);
Thread t4 = new Thread(consumer);
t.start();
t2.start();
t3.start();
t4.start();
}
}
一定在要finally{}中释放锁
【代码优化小结】:
应用封装,即将有共性的内容封装起来,在需要的时候调用。
善用匿名对象,对于直接使用的对象参数采用匿名减少代码量
善用接口类型和类类型的参数传递
请问java中的lock和synchronized区别是什么?
主要相同点:Lock能完成synchronized所实现的所有功能
主要不同点:Lock能有比synchronized更精确的语义和更好的性能。synchronized会自动释放锁,而Lock要求程序员手工释放,在finally{}快中