栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java多线程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java多线程

文章目录
  • 线程创建
    • Thread类
    • 实现runnable接口
      • 初识并发问题
    • 龟兔赛跑
    • Callable接口(了解)
    • 静态代理模式
    • Lamda表达式
  • 线程状态
    • 线程停止
    • 线程休眠
    • 线程礼让
    • 线程强制停止
    • 线程状态观测
  • 线程的优先级
  • 守护线程
  • 线程同步机制
    • 线程不安全
    • 同步方法
    • 补充:juc安全类的集合
    • 死锁
    • Lock锁
    • sychronized与Lock对比
  • 线程协程
    • 管程法
    • 信号灯法
  • 线程池

线程创建

Thread类
  • 初识
  • 子类继承Thread类具备多线程能力
  • 启动线程:子类对象.start()
  • 不建议使用:避免oop单继承局限性
package com.ljb.demo1;

//创建线程的方式之一:继承Thread类,重写run()方法, 调用 start开启线程
//总结:线程开启不一定立即执行,由cpu调用
public class TestTread extends Thread{
    @Override
    public void run() {
        //run()方法体
        for (int i = 0; i < 1220; i++) {
            System.out.println("我在看代码。。" + i);
        }
    }

    public static void main(String[] args) {
        //mian线程,主线程

        //创建线程对象
        TestTread tread = new TestTread();

        //调用start() 开启线程
        tread.start();

        for (int i = 0; i < 1220; i++) {
            System.out.println("我在学习多线程" + i);
        }

    }
}
实现runnable接口
  • 实现接口runnable具有多线程能力
  • 启动线程:传入对象+Thread对象.start()
  • 推荐使用:避免单继承的局限性,灵活方便,方便同一个对象被多个线程使用
package com.ljb.demo2;

//创建线程方式:实现Runnable接口,重写run()方法,执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("runnablr 接口..." + i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口实现类
        TestThread thread = new TestThread();

        new Thread(thread).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main函数" + i);
        }
    }
}
初识并发问题
package com.ljb.demo2;

//多线程同时操作一个对象
//买火车票

//发现问题,多个线程操作同一个资源情况下,出现线程紊乱
public class TestThread2 implements Runnable{
    //票
    private int tickNums = 20;

    @Override
    public void run() {
        while (true){
            if (tickNums <= 0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到第"+tickNums+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread2 thread2 = new TestThread2();
        new Thread(thread2).start();
    }

}
龟兔赛跑
package com.ljb.demo2;

public class Rice implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i < 101; i++) {
            //兔子睡觉
            if (Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameover(i);
            if (flag){
                System.out.println("比赛结束");
                break;
            }

            System.out.println(Thread.currentThread().getName()+"->跑了"+i+"步");


        }
    }
    //判断是否完成了比赛
    private boolean gameover(int steps){
        //判断是否有了胜利者
        if (winner != null){
            return true;
        }{
            if (steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner 是:" + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Rice rice = new Rice();
        new Thread(rice, "兔子").start();
        new Thread(rice, "乌龟").start();
    }
}
Callable接口(了解)
  • 实现Callable接口,需要返回值类型
  • 重写call方法,需要抛出异常
  • 创建目标对象
  • 创建执行服务[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n08DB3bz-1654157627580)(C:Users15751083927AppDataRoamingTyporatypora-user-imagesimage-20220420150936651.png)]
  • 提交执行
  • 获取结果
  • 关闭服务[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tSQOCQO3-1654157627582)(C:Users15751083927AppDataRoamingTyporatypora-user-imagesimage-20220420151033424.png)]

  • 好处:可以定义返回值,可以抛出异常
静态代理模式
package com.ljb.demo2;

//静态代理模式总结:
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处:
//  代理对象可以做很多真实对象做不了的事情
//  真是对象专注做自己的事情

public class StaticProxy {
    public static void main(String[] args) {
        webCompany web = new webCompany(new You());
        web.HappyMarry();
    }
}
interface Marry{

    void HappyMarry();
}
//真实角色 你去结婚
class You implements Marry{
    public void HappyMarry(){
        System.out.println("李锦彪和黄欣宇结婚了");
    }
}
//代理角色 帮助你结婚
class webCompany implements Marry{
    private Marry marry; //代理真实目标角色

    public webCompany(Marry marry) {
        this.marry = marry;
    }

    @Override
    public void HappyMarry() {
        before();
        this.marry.HappyMarry(); //这就是真实对象
        after();
    }

    private void after() {
        System.out.println("结婚之后,收尾款");
    }

    private void before() {
        System.out.println("结婚之前,布置现场");
    }
}
Lamda表达式
  • 避免匿名内部类定义过多
  • 可以让你的代码看起来更简洁
  • 去掉一堆没有意义的代码,只留下核心的逻辑

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MnZ99uJ5-1654157627584)(https://gitee.com/cool-dada/blog_img/raw/master/tree/master/img_markdown/202206021612620.png)]

package com.ljb.demo2;


public class TestLamda {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        //2.实现类
        ILike like = new Like();
        like.lambda();

        //3.静态内部类
        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类,没有类的名称,必须借助接口或者父类
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like = ()->{
            System.out.println("i like lambda5");
        };

        like.lambda();

    }
}
//1.定义一个函数接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

简化

  • 总结
    • lambda表达式智能有一行代码的情况下才能简化称为一行,如果有多行,那么就用代码块包裹
    • 前提是接口为函数式接口
    • 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号
package com.ljb.demo2;

public class TestLambda {

    public static void main(String[] args) {
        ILove love = null;
//        //1、lambda表示简化
//        love = (int a) -> {
//            System.out.println("i love you " + a);
//        };
//        //简化1、参数类型
//        love = (a) -> {
//            System.out.println("i love you " + a);
//        };
//        //简化2、简化括号
//        love = a -> {
//            System.out.println("i love you " + a);
//        };
        //简化3、简化花括号
        love = (a, b) -> System.out.println("i love you " + a + b);
        
        love.love(520, 1314);
    }
}

interface ILove{
    void love(int a, int b);
}
线程状态

线程停止
package com.ljb.demo3;

//测试stop
//1、建议线程正常停止--->利用次数,不建议死循环
//2、建议使用标志位-->设置一个标志位
//3、不要使用stop或者destroy 等过事或者jdk不建议使用的方法
public class TestStop implements Runnable{
    //1、设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run.thread" + i++);
        }
    }
    //2、设置一个公开的方法停止线程,转换标志法
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop stop = new TestStop();
        new Thread(stop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if (i == 900){
                //调用stop方法停止线程
                stop.stop();
                System.out.println("线程该停止了");
            }
        }

    }
}
线程休眠
  • 毫秒
  • 存在异常
  • 事件达到后线程进入就绪状态
  • 可以模拟网络延迟,倒计时等
  • 每个对象都有一个锁,sleep不会释放锁
package com.ljb.demo3;

//多线程同时操作一个对象
//买火车票

import sun.awt.windows.ThemeReader;

//发现问题,多个线程操作同一个资源情况下,出现线程紊乱
public class TestSleep implements Runnable{
    //票
    private int tickNums = 20;

    @Override
    public void run() {
        while (tickNums > 0) {
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->拿到第" + tickNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestSleep thread2 = new TestSleep();
        new Thread(thread2, "李锦彪").start();
        new Thread(thread2, "黄欣宇").start();
        new Thread(thread2, "锦欣宇").start();
    }

}

模拟倒计时

package com.ljb.demo3;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
        //打印当前系统时间
        Date start = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(start));
                start = new Date(System.currentTimeMillis());//获取系统当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0){
                break;
            }
        }
    }
}
线程礼让
  • 让当前正在执行的线程暂停,但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调整,礼让不一定成功!看cpu心情
package com.ljb.demo3;

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "李锦彪").start();
        new Thread(myYield, "黄欣宇").start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
    }
}
线程强制停止
  • Join合并线程,待此线程执行完毕后,再执行其他线程,其他线程阻塞
  • 可以想象成插队
package com.ljb.demo3;

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程vip来了:" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 400; i++) {
            if (i == 200){
                thread.join();//插队
            }
            System.out.println("main..." + i);
        }
    }
}
线程状态观测
package com.ljb.demo3;

//观察测试线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);  //NEW

        //观察启动后
        thread.start(); //启动线程
        state = thread.getState();
        System.out.println(state);  //Run

        while (state != Thread.State.TERMINATED){  //只有线程不终止,就一直输出状态
            Thread.sleep(100);
            state = thread.getState();  //更新线程状态
            System.out.println(state);  //输出状态
        }
    }
}
线程的优先级

package com.ljb.demo4;

//线程的优先级
public class TestPriority{
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        //设置优先级,在启动
        t1.start();

        t2.setPriority(2);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);  //MAX_PRIORITY=10
        t4.start();
    }
}
class  MyPriority extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}
守护线程

package com.ljb.demo4;

//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);  //默认是false表示是用户线程,正常的线程都是用户线程

        thread.start();  //上帝守护线程启动

        new Thread(you).start(); //你! 用户线程启动
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护你");
        }
    }
}

//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36000; i++) {
            System.out.println("你一生都开心的活着" + i);
        }
        System.out.println("byebye");
    }
}
线程同步机制 线程不安全
  • package com.ljb.demo4;
    
    import java.util.ArrayList;
    import java.util.List;
    
    //线程不安全
    public class UnsafeList {
        public static void main(String[] args) {
            List list = new ArrayList();
            for (int i = 0; i < 10000; i++) {
                new Thread(() -> {
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }
    
  • package com.ljb.demo4;
    
    //不安全的取钱
    //两个人去取钱
    public class UnsafeBank {
        public static void main(String[] args) {
            Account account = new Account(100, "结婚基金");
            Drawing draw = new Drawing(account, 50, "李锦彪");
            Drawing drawing = new Drawing(account, 100, "李锦彪");
    
            draw.start();
            drawing.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 drawingMoney;
        //现在有多少钱
        int nowMoney;
    
        public Drawing(Account account, int drawingMoney, String name) {
            super(name);
            this.account = account;
            this.drawingMoney = drawingMoney;
        }
    
        //取钱
    
        @Override
        public void run() {
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够,不能取");
                return;
            }
            //放大问题
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //余额
            account.money -= drawingMoney;
            //你手里的钱
            nowMoney += drawingMoney;
    
            System.out.println(account.name+"余额为"+account.money);
    
            System.out.println(this.getName()+"手里的钱:"+ nowMoney);
        }
    }
    
  • package com.ljb.demo4;
    
    //不安全的买票
    //线程不安全,有负数
    public class UnsafeBuyTicket {
        public static void main(String[] args) {
            BuyTicket buyTicket = new BuyTicket();
            new Thread(buyTicket, "李锦彪").start();
            new Thread(buyTicket, "黄欣宇").start();
            new Thread(buyTicket, "锦欣宇").start();
            new Thread(buyTicket, "爱你").start();
        }
    }
    class BuyTicket implements Runnable{
        private int ticketNums = 10;
        boolean flag = true; //外部停止方式
        @Override
        public void run() {
            //买票
            while (flag){
                try{
                    buy();
                }catch (Exception e){
                    System.out.println(e);
                }
            }
        }
        private void buy() throws InterruptedException {
            //判断是否有票
            if (ticketNums <= 0){
                return;
            }
            Thread.sleep(100);
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到第"+ticketNums--+"票");
        }
    }
    
同步方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VcjPgeHm-1654157627588)(https://gitee.com/cool-dada/blog_img/raw/master/tree/master/img_markdown/202206021612793.png)]

package com.ljb.demo4;

//不安全的买票
//线程不安全,有负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket, "李锦彪").start();
        new Thread(buyTicket, "黄欣宇").start();
        new Thread(buyTicket, "锦欣宇").start();
        new Thread(buyTicket, "爱你").start();
    }
}
class BuyTicket implements Runnable{
    private int ticketNums = 10;
    boolean flag = true; //外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try{
                buy();
            }catch (Exception e){
                System.out.println(e);
            }
        }
    }
    //synchronized同步方法,锁得是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            return;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到第"+ticketNums--+"票");
    }
}
package com.ljb.demo4;

//不安全的取钱
//两个人去取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Drawing draw = new Drawing(account, 50, "李锦彪");
        Drawing drawing = new Drawing(account, 100, "李锦彪");

        draw.start();
        drawing.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 drawingMoney;
    //现在有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱

    @Override
    public void run() {

        //锁的对象是变化的量
        synchronized (account){
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println("银行钱不够,不能取");
                return;
            }
            //放大问题
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //余额
            account.money -= drawingMoney;
            //你手里的钱
            nowMoney += drawingMoney;

            System.out.println(account.name+"余额为"+account.money);

            System.out.println(this.getName()+"手里的钱:"+ nowMoney);
        }

    }
}
package com.ljb.demo4;

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

//线程不安全
public class UnsafeList {
    public static void main(String[] args) {
        List list = new ArrayList();
        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());
    }
}
补充:juc安全类的集合
package com.ljb.demo4;

import java.util.concurrent.CopyOnWriteArrayList;

//测试juc安全类的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());

    }

}
死锁

package com.ljb.demo4;

//死锁:多个线程互相抱着对象需要的资源,然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup m1 = new Makeup(0, "李锦彪");
        Makeup m2 = new Makeup(1, "黄欣宇");

        m1.start();
        m2.start();
    }
}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
class Makeup extends Thread{
    //需要的资源只有一份,用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice; //选择
    String girlName; //姓名
    Makeup(int choice, String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @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.girlName+"获得口红的锁");
                Thread.sleep(1000); //一秒钟后获得口红的锁
            }
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(1000);//一秒钟后获得镜子的锁
            }
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
            }
        }
    }
}
Lock锁

package com.ljb.demo4;

import java.util.concurrent.locks.ReentrantLock;

//测试lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    int tick = 10;

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

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if (tick>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(tick--);
                }else{
                    break;
                }
            }finally {
                lock.unlock(); //解锁
            }

        }
    }
}
sychronized与Lock对比

线程协程

管程法
package com.ljb.demo4;

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

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

        new Product(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Product extends Thread{
    SysContainer container;

    public Product(SysContainer container) {
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "鸡");
        }
    }
}

//消费者
class Consumer extends Thread{
    SysContainer container;

    public Consumer(SysContainer container) {
        this.container = container;
    }

    //消费

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->" + container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken extends Thread{
    int id; //产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class  SysContainer{

    //需要一个容器大小
    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.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断是否消费
        if (count == 0){
            //等待生产者生产,消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了,通知生产者生产
        this.notifyAll();
        return chicken;

    }
}
信号灯法
package com.ljb.demo4;

//测试生产者消费者问题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++) {
            tv.watch();
        }
    }
}
//产品-->节目
class TV{

    //演员表演, 观众等待
    //观众观看, 演员等待
    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;
    }
}
线程池

package com.ljb.demo4;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {

        //1、创建线程池
        //newFixedThreadPool线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        //2、关闭连接
        service.shutdown();
    }
}

class MyPool implements Runnable{


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());

    }
}

}
}
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;
}

}

# 线程池

[外链图片转存中...(img-T9FJKNea-1654157627592)]

```java
package com.ljb.demo4;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {

        //1、创建线程池
        //newFixedThreadPool线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        //2、关闭连接
        service.shutdown();
    }
}

class MyPool implements Runnable{


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());

    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/946966.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号