线程协作4

线程协作

生产者消费者模式

线程通信方法

解决一

管程法

package test1;
//测试生产者消费者模型--》利用缓冲区解决，管程法
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        Productor productor = new Productor(synContainer);
        Consumer consumer = new Consumer(synContainer);
        productor.start();
        consumer.start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Product(i));
            System.out.println("生产了" + i + "个产品");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->" + container.pop().id + "产品");
        }
    }
}
//产品
class Product{
    int id;
    public Product(int id) {
        this.id = id;
    }
}
//缓冲区
class  SynContainer{
    private int count = 0;
    Product[] products = new Product[10];//容器，产品类型的数组
    public synchronized void push(Product product){//生产者放入产品需要使用synchronized方法
        //如果容器满了则需要等待消费者消费
        if(count == 10){
            //通知生产者等待，消费者消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没满则告诉生产者生产，丢入产品
        products[count] = product;
        count++;
        //通知消费者消费
        this.notifyAll();
    }
//消费者消费产品
public synchronized Product pop(){
        //判断能否消费
    if(count == 0){
        //通知消费者等待，生产者生产
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //如果没空则告诉消费者消费
    count--;
    Product product = products[count];

    //通知生产者生产
    this.notifyAll();
    return product;
}
}
/*有一个生产者，还有一个消费者，生产者只管生产，消费者只管消费，产品是一个对象实例，被生产者生产，又被消费者消费，还需要一个缓冲区，如果缓冲区满了，就通知消费者消费，再通知生产者等待生产，如果没满，就可以将生产的产品放入缓冲区，然后可以通知消费者消费，
再有一个消费方法，如果缓冲区空了，就通知消费者停止消费，然后如果没满，就将缓冲区中的一个产品消费，然后再通知生产者生产产品*/

信号灯法

标志位解决

package test1;
//信号灯法,标志位解决
public class Demo3 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Actor(tv).start();
        new Watcher(tv).start();
    }
}
//生产者--》演员，表演
class Actor extends Thread{
    TV tv;
    public Actor(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2!= 0){
                try {
                    this.tv.action("快乐大本营");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    this.tv.action("抖音！！！！！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//消费者————》观众，看表演
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//产品--》节目，表演
class TV{
    //演员表演，观众等待，true
    //观众观看，演员等待，false
    String voice;//表演的节目
    boolean flag = true;
    //表演
    public synchronized void action(String voice) throws InterruptedException {
        if (!flag){
            this.wait();
        }
        System.out.println("演员表演了"+ voice);
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了" + voice);
        //通知演员
        this.notifyAll();
        this.flag = !this.flag;
    }

}

线程池

package test1;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
    public static void main(String[] args) {
        //开启线程池，10个
        ExecutorService service = Executors.newFixedThreadPool(10);
        //提交线程实例，执行run方法
        service.submit(new Acted());
        service.submit(new Acted());
        service.submit(new Acted());
        service.submit(new Acted());
        service.submit(new Acted());
        service.shutdown();//关闭线程池
    }
}
class Acted implements Runnable
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

package test1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestA {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        B b = new B();
        new Thread(b).start();
        C c = new C();
        c.start();
        D d = new D();
        FutureTask<Integer> task = new FutureTask<Integer>(d);
        Thread thread = new Thread(task);
        thread.start();
//        thread.start();若放在task。get（）后面则会出现线程阻塞
        Integer integer = task.get();
        System.out.println(integer);


    }
}
class B implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "Runnable");
    }
}
class C extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "Thread");
    }
}
class D implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "Callable");
    return 100;
    }
}