Day33

Yeild礼让

join插队

State观测线程状态

线程的优先级

守护线程

线程同步

案例：

1. 不安全取钱

package com.nan.Thread.syn;

//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,"you",50);
        Drawing wife = new Drawing(account,"wife",100);

        you.start();
        wife.start();
    }
}
//账户
class Account{
    int money;
    String name;
    public Account(int money,String name){
        this.money=money;
        this.name=name;
    }
}
//银行：模拟取款
class Drawing extends Thread {
    //账号
    Account account;
    //原有多少钱
    int nowmoney;
    //取了多少钱
    int drawingmoney;
    public Drawing(Account account, String name, int drawingmoney){
        super(name);
        this.account=account;
        this.drawingmoney=drawingmoney;
    }
    //取钱
    //synchronized 默认锁的是this
    @Override
    public void run() {
        //锁的对象就是变化的零，需要增删改的对象
        synchronized (account){
            //判断有没有钱
            if (drawingmoney>account.money){
                System.out.println(Thread.currentThread().getName()+"钱不够，无法取出");
                return;
            }
            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额=余额—你取出来的钱
            account.money=account.money-drawingmoney;
            //你手里的钱
            nowmoney=nowmoney+drawingmoney;

            System.out.println(account.name+"卡上余额为："+account.money);
            //Thread.currentThread().getName()=this.getName()
            System.out.println(this.getName()+"手里的钱为："+nowmoney);
        }

    }
}

2. 不安全买票

package com.nan.Thread.syn;

//不安全买票
public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"1").start();
        new Thread(station,"2").start();
        new Thread(station,"3").start();
    }
}
class BuyTicket implements Runnable{

    //票
    private int ticketNums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag) {
                buy();
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized 同步方法,锁的是this
    private synchronized void buy(){
        //判断是否有票
        if (ticketNums<=0){
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

3. 不安全列表

package com.nan.Thread.syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){list.add(Thread.currentThread().getName());}
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

package com.nan.Thread;

import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
//死锁：多个线程互相抱着对方需要的资源，然后形成僵持。
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"LSH");
        Makeup g2 = new Makeup(1,"ZKX");

        g1.start();
        g2.start();
    }
}
//口红
class LipStick{
}
//镜子
class Mirror{
}
class Makeup extends Thread {

    //需要的资源只有一份，用static来保证只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

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

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

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆，互相持有对方的索，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipStick) {//获得口红的锁
                System.out.println(this.name + "获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror) {//1s后想获得镜子
                System.out.println(this.name + "获得镜子的锁");
            }
        } else {
            synchronized (lipStick) {
                System.out.println(this.name + "获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (mirror) {
                System.out.println(this.name + "获得口红的锁");
            }
        }
    }
}

Lock锁

ReentrantLock可重复锁。

线程协作

管程法

package com.nan.Thread;

//测试：生产者消费者模型-->利用缓冲区解决：管程法

import javax.swing.plaf.synth.SynthConstants;

//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor (SynContainer container){
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            container.push(new Chicken(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 Chicken{
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //如果容器满了，就需要等待消费者消费
        if (count == chickens.length) {
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了。
        this.notify();
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken =chickens[count];
        //吃完了，通知生产者生产
        this.notify();
        return chicken;
    }
}

信号灯法

//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者--->演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if( i%2 == 0){
                this.tv.play("快乐大本营播放中");
            }else {
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}
//消费者--->观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}
//产品--->节目
class TV {
    //演员表演的时候，观众等待  T
    //观众观看的时候，演员等待  F
    String voice;//表演的节目
    boolean flag = true;
    //表演
    public synchronized void play(String voice) {
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        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;
    }
}

线程池

总结