java多线程：线程的通信、唤醒等待机制、生产消费者模式、Lock

线程的通信：打印机打印–不断的输入输出

package com.qianfeng.test;
/*
* 线程的通信：
* 分析：
* 需要两个线程--输入线程和输出线程
* 需要两个任务--输入任务和输出任务
* 需要一份数据
*
* 实现：打印机打印--不断的输入不断的输出
*
*/
public class Demo2 {

public static void main(String[] args) {

//1.创建数据类对象
Des des =new Des();
//创建任务类对象并绑定数据
Input input = new Input(des);
Output output = new Output(des);
//3.创建线程
Thread inputThread = new Thread(input);
Thread outputThread = new Thread(output);
//4.开启线程
inputThread.start();
outputThread.start();

}
}

//创建数据类
class Des{
String name;
String sex;
}

//创建输入任务
class Input implements Runnable{

Des des;
public Input(Des des){
this.des=des;
}

public void run() {
/*
* 分析：需要输入任务与输出任务共用一把锁，保证两个任务之间是同步的。
* 给两个任务加一把锁，锁可以是des或Object.class
*
* 不建议使用Object.class，因为Object.class应用范围太大，其它地方可能也会用到。
* 使用des最合适，因为它只被两个线程共享。
*
* 注意：只给一个任务加锁无法实现两个线程的同步。
*/
int i = 0;
while(true){
synchronized (des) {
if (i==1) {
des.name = "凤姐";
des.sex = "男" ;
}else {
des.name = "芙蓉姐姐";
des.sex = "女" ;
}
i=(i+1)%2;
}
}
}
}

//创建输出任务
class Output implements Runnable{

Des des;
public Output(Des des){
this.des=des;
}

public void run() {
while(true){
synchronized (des) {
System.out.println("姓名："+des.name+"  性别"+des.sex);
}
}
}
}

唤醒等待机制，wait()/notify()/notifyAll()

package com.qianfeng.test;

/*
* 线程的通信：
* 分析：
* 需要两个线程--输入线程和输出线程
* 需要两个任务--输入任务和输出任务
* 需要一份数据
*
* 实现：打印机打印--一次输入一次输出
*
* 使用唤醒等待机制实现：wait()/notify()/notifyAll()等
* wait()：让当前的线程进入等待的状态，他会被放入一个池子（线程池），失去了抢cpu的能力，等待唤醒。（锁--相当于给当前线程做了一个标记）
* notify()：让当前的线程从等待线程唤醒，相当于从池子中取出线程。（唤醒的是同一把锁下的任意一个线程）
* notifyAll()：唤醒的是同一把锁下的所有线程。
*/
public class Demo3 {

public static void main(String[] args) {

// 1.创建数据类对象
Des1 des = new Des1();
// 创建任务类对象并绑定数据
Input1 input = new Input1(des);
Output1 output = new Output1(des);
// 3.创建线程
Thread inputThread = new Thread(input);
Thread outputThread = new Thread(output);
// 4.开启线程
inputThread.start();
outputThread.start();

}
}

// 创建数据类
// 封装类的原则：是你的活你做，不是你的活不要做。
class Des1 {
String name;
String sex;
boolean flag = false;// 创建一个标识，控制唤醒与等待的切换。

// 获取数据--处理输入
public synchronized void setData(String name, String sex) {
if (flag == true) {
try {// 让输入线程等待，当flag值为true的时候
// 在执行代码的时候，这里对应的是哪个线程，锁对象操作的就是哪个线程。
wait();// 只要一执行wait，线程会立刻停在这里，等待下次唤醒。
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.name = name;
this.sex = sex;

flag = !flag;
//// 唤醒输出线程。
// 当执行唤醒的时候，在线程池中没有找到被当前的锁标记的线程，我们称为空唤醒，空唤醒对程序没有影响，程序允许空唤醒。
notify();

}

// 将数据打印到控制台--处理输出
public synchronized void getData() {
if (flag == false) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("姓名：" + name + "  性别" + sex);
flag = !flag;
notify();
}

}

// 创建输入任务
class Input1 implements Runnable {

Des1 des;
public Input1(Des1 des) {
this.des = des;
}

public void run() {

int i = 0;
while (true) {
if (i == 1) {
des.setData("凤姐", "男");
} else {
des.setData("芙蓉姐姐", "女");
}
i = (i + 1) % 2;
}
}
}

// 创建输出任务
class Output1 implements Runnable {

Des1 des;
public Output1(Des1 des) {
this.des = des;
}

public void run() {
while(true){
des.getData();
}

}
}

多线程设计模式：单生产者单消费者

package com.qianfeng.test;
/*
* 多线程的设计模式:生产者消费者
* 两类:
* 1.单生产者单消费者
* 2.多生产者多消费者
*
* 先研究单生产者单消费者
* 分析:
* 生产线程,消费线程
* 生产任务,消费任务
* 产品
*/
public class Demo4 {
public static void main(String[] args) {
//1.创建产品
Product product = new Product();
//2.创建生产任务,消费任务
Producer producer = new Producer(product);
Consumer consumer = new Consumer(product);

//3.创建生产线程,消费线程
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);

//4.开启线程
t1.start();
t2.start();
}
}

//创建产品类
class Product{
String name;
double price;
int count;

boolean flag = false;//用来在唤醒与等待之间进行切换

//为生产准备数据
public synchronized void setProduce(String name,double price){
if (flag == true) {
try {
wait();//让生产线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.name = name;
this.price = price;

System.out.println(Thread.currentThread().getName()+"  生产了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);
count++;

flag = ! flag;
notify();//唤醒消费线程
}
//为消费准备数据
public  synchronized void consume() {
if (flag == false) {
try {
wait();//让消费线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

flag = ! flag;
notify();//唤醒生产线程
}
}

//创建生产任务
class Producer implements Runnable{
Product product;
public Producer(Product product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.setProduce("bingbing", 10);
}
}
}
//创建消费任务
class Consumer implements Runnable{
Product product;
public Consumer(Product product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.consume();
}
}
}

多线程设计模式：多生产者多消费者

package com.qianfeng.test;
/*
* 多线程的设计模式:生产者消费者
* 两类:
* 1.单生产者单消费者
* 2.多生产者多消费者
*
* 研究多生产者多消费者
* 分析:
* 生产线程,消费线程有多个
* 生产任务,消费任务各有一个
* 产品一个
*/
public class Demo5 {
public static void main(String[] args) {
//1.创建产品
Product1 product = new Product1();
//2.创建生产任务,消费任务
Producer1 producer = new Producer1(product);
Consumer1 consumer = new Consumer1(product);

//3.创建生产线程,消费线程
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);

//4.开启线程
t0.start();
t1.start();
t2.start();
t3.start();

}
}

//创建产品类
class Product1{
String name;
double price;
int count;

boolean flag = false;//用来在唤醒与等待之间进行切换

//为生产准备数据
public synchronized void setProduce(String name,double price){
while (flag == true) {
try {
wait();//让生产线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.name = name;
this.price = price;

System.out.println(Thread.currentThread().getName()+"  生产了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);
count++;

flag = ! flag;
//notify();//唤醒消费线程
notifyAll();
}
//为消费准备数据
public  synchronized void consume() {
while (flag == false) {
try {
wait();//让消费线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

flag = ! flag;
//notify();//唤醒生产线程
notifyAll();
}
}

//创建生产任务
class Producer1 implements Runnable{
Product1 product;
public Producer1(Product1 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.setProduce("bingbing", 10);
}
}
}
//创建消费任务
class Consumer1 implements Runnable{
Product1 product;
public Consumer1(Product1 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.consume();
}
}
}

Lock，Condition。Lock与synchronized的比较

package com.qianfeng.test;

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

/*
* Lock:
* 比较synchronized和Lock
* 1.synchronized:从jdk1.0开始使用----隐式同步
* 	synchronized(锁对象){//获取锁   我们将这里的锁称为锁旗舰或者监听器
* 		同步的代码
* }//释放锁
* 2.Lock:从jdk1.5开始使用----显示同步
* 原理:Lock是接口,我们要通过他的子类工作
* 具体的工作流程:
* 	首先调用lock的lock()方法,获取锁
*      进行同步操作的代码
*  调用lock的unlock()方法,释放锁
*
*  使用场景总结:
*  1.当进行多生产者的消费者的时候,使用lock,其他的使用synchronized
*
*  使用效率上lock比synchronized高.
*/

public class Demo6 {
public static void main(String[] args) {
//1.创建产品
Product2 product = new Product2();
//2.创建生产任务,消费任务
Producer2 producer = new Producer2(product);
Consumer2 consumer = new Consumer2(product);

//3.创建生产线程,消费线程
Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(consumer);
Thread t3 = new Thread(consumer);

//4.开启线程
t0.start();
t1.start();
t2.start();
t3.start();

}
}

//创建产品类
class Product2{
String name;
double price;
int count;

boolean flag = false;//用来在唤醒与等待之间进行切换

//创建Lock的对象
Lock lock = new ReentrantLock();

//创建用于生产线程的Condition对象
Condition proCon = lock.newCondition();
//创建用于消费线程的Condition对象
Condition conCon = lock.newCondition();

//为生产准备数据
public  void setProduce(String name,double price){
try {
lock.lock();//获取锁
while (flag == true) {
try {
//wait();//让生产线程等待
proCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.name = name;
this.price = price;

System.out.println(Thread.currentThread().getName()+"  生产了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);
count++;

flag = ! flag;
//notify();//唤醒消费线程
//notifyAll();
conCon.signal();

} finally {//必须执行的代码
lock.unlock();//释放锁
}

}
//为消费准备数据
public   void consume() {
try {
lock.lock();
while (flag == false) {
try {
//wait();//让消费线程等待
conCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

flag = ! flag;
//notify();//唤醒生产线程
//notifyAll();
proCon.signal();
} finally {
lock.unlock();
}

}
}

//创建生产任务
class Producer2 implements Runnable{
Product2 product;
public Producer2(Product2 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.setProduce("bingbing", 10);
}
}
}
//创建消费任务
class Consumer2 implements Runnable{
Product2 product;
public Consumer2(Product2 product) {
super();
this.product = product;
}
public void run() {
while (true) {
product.consume();
}
}
}

守护线程，setDaemon。

package com.qianfeng.test;
/*
* 守护线程：相当于后台线程，依赖于前台线程。正常情况下，当前台线程结束的时候，不管后台线程有没有结束，都会立即结束。
* 典型的守护线程：垃圾回收线程。
*
*/
public class Demo7 {

public static void main(String[] args) {

Test test = new Test();
Thread thread = new Thread(test);
/*
* 当程序调用setDaemon的时候，并且将参数设置为true，他就变成了守护线程。
* 注意：这个方法一定要在start方法之前调用。
*/
thread.setDaemon(true);
thread.start();

int i = 0;
while(true){
if (i++ == 10 ) {
System.out.println(Thread.currentThread().getName()+" i"+i);
break;//主线程结束
}
}
}
}

class Test implements Runnable{

public void run() {
while(true){
System.out.println("守护线程");
}

}
}

join方法

package com.qianfeng.test;
/*
* join()方法：
* 原理：程序一旦调用了join方法，他的优先级会高于主线程。意思是说，主线程会等当前线程执行完后再去执行。
* 注意：这个线程的优先级只比main高，对其它的线程没有影响。
*
*/
public class Demo8 {

public static void main(String[] args) {

Dog dog = new Dog();
Thread thread0 = new Thread(dog);
Thread thread1 = new Thread(dog);
thread0.start();
thread1.start();

/*
* 当线程开始工作后，让thread0调用join（）方法，它的优先级会高于main线程。
* 注意：join（）方法必须在线程开始工作后执行
*/
try {
thread0.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" i"+i);
}

}
}

class Dog implements Runnable{

public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" i"+i);
}

}

}