多线程__【线程间通信】【等待唤醒机制】【多生产多消费】【Lock&Condition接口】

---------------------------------------- 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{}快中

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