Java SE（多线程之死锁和生产者消费者问题）

多线程之死锁和生产者消费者问题

死锁

package com.java.thread;

/*模拟死锁
* 模拟两个人分别抢对方的资源，但是都不把自己的资源释放，产生死锁
* 多个线程相互抱着对方的资源，然后形成僵持*/
public class DeadLock {
    public static void main(String[] args) {
        Transform boy1=new Transform(0,"boy1");
        Transform boy2=new Transform(1,"boy2");

        boy1.start();
        boy2.start();
    }
}

//玩具汽车
class Car{
}

//玩具火车
class Train{
}

//玩具交换
class Transform extends Thread{
    //使用static保证需要的资源只有一份
    static Car car=new Car();
    static Train train = new Train();

    int choice;//选择
    String name;//使用的人

    Transform(int choice,String name){
        this.choice=choice;
        this.name=name;
    }

    @Override
    public void run() {
        //交换
        try {
            transform();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void transform() throws InterruptedException {
        if(choice==0){
            synchronized (car){
                System.out.println(this.name+"获得了玩具汽车");
                Thread.sleep(1000);
                synchronized (train){
                    System.out.println(this.name+"获得了玩具火车");
                }
            }
        }else{
            synchronized (train){
                System.out.println(this.name+"获得了玩具火车");
                Thread.sleep(2000);
                synchronized (car){
                    System.out.println(this.name+"获得了玩具汽车");
                }
            }
        }
    }
}
/*死锁产生的四个必要条件：
* 1.互斥条件：一个资源每次只能被一个资源使用
* 2.请求与保持条件：一个进程因请求资源而阻塞时，对已经获得的资源保持不放
* 3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
* 4.循环等待条件：若干进程之间形成一张头尾相接的循环等待资源关系
* 解决方法：破坏其中任意一种或者多种条件*/

Lock锁

package com.java.thread;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(ticket,"John").start();
        new Thread(ticket,"Jams").start();
        new Thread(ticket,"Love").start();
    }
}

class Ticket implements Runnable{
    int ticketNums=10;//设置票数量

    private final ReentrantLock lock =new ReentrantLock();//定义Lock锁

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try{
                lock.lock();//加锁
                if(ticketNums>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
                }else{
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

生产者-消费者问题

//在多核cpu的笔记本上运行代码可能会出现先消费后生产的情况，也可能是代码问题，此代码只是初步演示生产者-消费者问题
package com.java.thread;

//测试生产者-消费者问题-->利用缓冲区解决:管程法
//生产者、消费者、产品、缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Product(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Product extends Thread{
    SynContainer container;
    public Product(SynContainer container){
        this.container=container;
    }

    //生产
    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            container.push(new Things(i));
            System.out.println("生产了"+i+"个");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container=container;
    }

    //消费
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"个");
        }
    }
}

//产品
class Things {
    int id;
    Things(int id){
        this.id=id;
    }
}

//缓冲区
class SynContainer{
    Things[] things=new Things[10];//设置容器大小

    int count=0;//设置计数器

    //生产者生产产品
    public synchronized void push(Things thing){
        if (count==things.length){//如果容器满了，就需要等待消费者消费产品
            //通知消费者消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，就需要生产产品
        things[count]=thing;
        count++;

        //可以通知消费者消费了
        this.notify();
    }

    //消费者消费产品
    public synchronized Things pop(){
        //判断是否消费
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消费者消费
        count--;
        Things thing=things[count];

        //消费完毕，通知生产者生产
        this.notify();
        return thing;
    }
}

由生产者-消费者问题引申出的解决办法二——>信号灯法

package com.java.thread;

//生产者-消费者问题-->利用信号灯法解决
//把生产者-消费者问题引申为两个线程打印奇偶数问题，利用信号灯法控制线程的之间的通信
public class TestPC2 {
    public static void main(String[] args) {
        OutPut outPut=new OutPut();
        new Odd(outPut).start();
        new Even(outPut).start();
    }
}

//打印奇数
class Odd extends Thread{
    OutPut outPut;
    public Odd(OutPut outPut){
        this.outPut=outPut;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if(i%2!=0){
                outPut.OutOdd(i);
            }
        }
    }
}

//打印偶数
class Even extends Thread{
    OutPut outPut;
    public Even(OutPut outPut){
        this.outPut=outPut;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if(i%2==0){
                outPut.OutEven(i);
            }
        }
    }
}


//打印方法
class OutPut{
    //打印奇数时，偶数等待 T
    //打印偶数时，奇数等待 F
    int number;//打印的数
    Boolean flag=true;//标志位

    //打印奇数
    public synchronized void OutOdd(int number){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //打印奇数
        System.out.println("打印奇数-->"+number);
        //打印完毕，通知打印机打印偶数
        this.notify();//通知唤醒

        this.flag=!this.flag;
    }

    //打印偶数
    public synchronized void OutEven(int number){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //打印偶数
        System.out.println("打印偶数-->"+number);
        //打印完毕，通知打印机打印奇数
        this.notify();//通知唤醒

        this.flag=!this.flag;
    }
}

多线程扩展-线程池

package com.java.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //创建服务,创建线程池
        //newFixedThreadPool 参数：线程池大小
        ExecutorService service= Executors.newFixedThreadPool(10);

        //启动服务
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());

        //关闭服务
        service.shutdown();

    }
}

class MyPool implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}