Day19,20,21 java多线程:线程创建(Thread、Runnable、Callable),Lamda表达式,静态代理,线程状态,线程同步（锁）,线程协作（wait、notify）

于 2020-09-20 17:00:14 发布
阅读量426 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java 多线程 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37207539/article/details/108695274
版权

线程简介

多任务

现实生活中太多这样同时做多件事情的例子，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。

多线程

普通方法调用和多线程

在这里插入图片描述

程序、进程、线程

在这里插入图片描述

Process与Thread

在这里插入图片描述

本章核心概念

在这里插入图片描述

线程创建

三种创建方式

Thread、Runnable、Callable
在这里插入图片描述

继承Thread类

在这里插入图片描述

//创建线程方式一：继承Thread类，重写run（）方法，嗲用stary开启线程
//总结：注意，线程开启不一定立即执行，由cpu调度执行
public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程
        for (int i = 0; i < 10; i++) {
            System.out.println("1" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法。start()和main（）都在执行，交替执行。
        testThread1.start();
        //调用run（）方法。先执行run（）结束，main（）再接着走。
        //testThread1.run();
        for (int i = 0; i < 10; i++) {
            System.out.println("2" + i);
        }
    }
}

多线程下载图片

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//联系Thread，实现多线程同步下载图片
public class TsetThread2 extends Thread{
    private  String url;//网络图片地址
    private String name;//文件名

    public TsetThread2(String url,String name) {
        this.url = url;
        this.name = name;
    }

    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
    }

    public static void main(String[] args) {
        TsetThread2 t1 = new TsetThread2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu1.png");
        TsetThread2 t2 = new TsetThread2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu2.png");
        TsetThread2 t3 = new TsetThread2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu3.png");

        //三个同时执行
        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法");
        }
    }
}

实现Runnable接口

在这里插入图片描述

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

    public static void main(String[] args) {
        //创建线程对象，通过线程对象来开启我们的线程,代理
        new Thread(new TestThread3()).start();
        for (int i = 0; i < 10; i++) {
            System.out.println("2" + i);
        }
    }
}

实现Callable接口

在这里插入图片描述

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建方式三：实现callable接口、
/*
实现callable接口的好处
1.可以定义返回值
2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private  String url;//网络图片地址
    private String name;//文件名

    public TestCallable(String url,String name) {
        this.url = url;
        this.name = name;
    }

    //下载图片线程的执行体
    @Override
    public Boolean call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu1.png");
        TestCallable t2 = new TestCallable("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu2.png");
        TestCallable t3 = new TestCallable("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","baidu3.png");

        //创建执行服务：
        ExecutorService ser= Executors.newFixedThreadPool(3);

        //提交执行,也是同步执行。
        Future<Boolean>  r1=ser.submit(t1);
        Future<Boolean>  r2=ser.submit(t2);
        Future<Boolean>  r3=ser.submit(t3);

        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();

        //关闭服务
        ser.shutdownNow();
    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法");
        }
    }
}

小结

在这里插入图片描述

Lamda表达式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

推导第1步：

/*
推导Lambdal表达式
 */
public class TestLambdal {
    //3.静态内部类
    static class Like2 implements Ilike {
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        //外部类调用
        Ilike like = new Like();
        like.lambda();

        //静态内部类调用
        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");
    }
}

推导第2步：

/*
推导Lambdal表达式
 */
public class TestLambda2 {

    public static void main(String[] args) {
        Ilove love=(int a)-> {
                System.out.println(a);
        };

        //简化1：参数类型
        love=(a)-> {
            System.out.println(a);
        };
        //简化2：简化括号
        love=a-> {
            System.out.println(a);
        };
        //简化3：去掉花括号
        love=a->System.out.println(a);

        /*总结：
        1.lambda表达式智能有一行代码的情况下才能简化成一行，如果是多行，那么就用代码块包裹
        2.前期是函数式接口
        3.多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号。
         */

        love.love(520);
    }
}

//1.定义一个函数式接口
interface Ilove {
    void love(int a);
}

静态代理

//静态代理模式总结：
//真实对象和代理对象都要实现同一接口
//代理对象要代理真实角色
/*
好处：
1.代理对象可以做很多真实对象做不了的事情。
2.真实对象可以专注做自己的事情。
 */
public class StaticProxy {
    public static void main(String[] args) {
        //Thread代理我们runnable接口，调用start方法
        new Thread(() -> System.out.println("我爱你")).start();//线程底部实现原理，就是静态代理
        //HappyMarry()相当于线程中的start（）
        new WeddingCompany(new You()).HappyMarry();

    }

}

interface Marry {
    //人间四大喜事
    //久旱逢甘露
    //他乡遇故知
    //金榜提名时
    void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("老师结婚了。");
    }
}

//代理角色，帮你结婚.比作婚庆公司
class WeddingCompany implements Marry {

    //代理谁-》真实目标
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

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

    private void before() {
        System.out.println("结婚之前，布置现场");
    }

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

}

线程状态

在这里插入图片描述
在这里插入图片描述

线程方法

在这里插入图片描述

停止线程

在这里插入图片描述

//测试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 testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i <= 1000; i++) {
            System.out.println("主线程main"+i);
            if (i == 900) {
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("子线程停止");
            }
        }
    }
}

线程休眠sleep

在这里插入图片描述

 Thread.sleep(200);//模拟延时
//模拟网络延时：可以放大问题的发生性

线程礼让yield

在这里插入图片描述

//测试礼让线程
//礼让不一定成功，看cpu心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"1号线程").start();
        new Thread(myYield,"2号线程").start();
    }

}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程结束执行");

    }
}

线程插队join

在这里插入图片描述

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

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

        //主线程
        for (int i = 0; i < 500; i++) {
            System.out.println("main"+i);
            if (i == 200) {
                thread.join();//插队
            }
        }
    }
}

线程状态观测getState()

5大状态

//观察测试线程状态
public class TestState {
    public static void main(String[] args) {
        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();
        System.out.println(thread.getState());//RUNNABLE

        while(thread.getState()!=Thread.State.TERMINATED){
            //只要线程不终止，就一直输出状态
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(thread.getState());
            //TIMED_WAITING---->TERMINATED
        }
        //死亡之后的线程不能再启动
    }
}

线程优先级setPriority(5)

在这里插入图片描述

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);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.start();//默认5

        t2.setPriority(1);
        t2.start();

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

        t4.setPriority(Thread.MAX_PRIORITY);//10
        t4.start();

//        t5.setPriority(-1);//报错
//        t5.start();

//        t6.setPriority(11);//报错
//        t6.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守护线程setDaemon(true)

在这里插入图片描述

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

        Thread tgod = new Thread(god);
        tgod.setDaemon(true);//默认是false表示用户线程，正常线程都是用户线程。
        tgod.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 < 36500; i++) {
            System.out.println("你的一生都开心的活着");
        }
        System.out.println("goodby world!");
    }
}

线程同步

多个线程操作同一个资源

并发

在这里插入图片描述

案例1：多人买火车票

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

//发现问题：多个线程操作同一个资源情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable {

    //票数
    private int ticketNums = 10;

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

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

案例2：龟兔赛跑-Race

public class Race implements Runnable {
    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100;) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")) {
                i+=15;
                if (i%10 == 0) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }else
            {
                i++;
            }
            //判断比赛是否结束
            if (gameOver(i)) {
                break;//比赛结束停止程序
            }
            System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");

        }
    }

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

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

线程同步

在这里插入图片描述

队列和锁

在这里插入图片描述

在这里插入图片描述

三大不安全案例

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

案例1：不安全买票

//不安全的买票
//线程不安全，有负数
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();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticketNums = 10;
    private boolean flag = true;//外部停止方式

    @Override
    public void run() {
        //买票
        while (flag) {
            buy();
        }
    }

    private void buy() {
        //判断是否有票
        if (ticketNums <= 0) {
            flag=false;
            return;
        } else {
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
        }
    }
}

案例2：不安全取钱

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

        you.start();
        girlfriend.start();

    }
}

//账户
class Account {
    int money;//余额
    String name;//卡的名字

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款.
//当多个线程操作同一个对象，推荐使用Runnable接口
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() + "钱不够，取不了");
        }
        //模拟延时
        try {
            //sleep可以放大问题的发生性
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-你取的钱
        account.money = account.money - drawingMoney;

        //你手里的钱
        nowMoney=nowMoney+drawingMoney;

        System.out.println(account.name+"账户余额为："+account.money);
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}

案例3：线程不安全的集合

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(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

        System.out.println(list.size());
        //输出9998
        //因为可能多个线程占用了list里面同一个位置
    }
}

同步方法Synchonized 方法名

在这里插入图片描述
在这里插入图片描述

不安全案例1加锁修改：同步方法

//不安全的买票
//线程不安全，有负数
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();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticketNums = 10;
    private boolean flag = true;//外部停止方式

    @Override
    public void run() {
        //买票
        while (flag) {
            buy();
        }
    }

    private synchronized void buy() {
        //判断是否有票
        if (ticketNums <= 0) {
            flag=false;
            return;
        } else {
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
        }
    }
}

同步块Synchonized（Obj）{}

在这里插入图片描述

不安全案例2加锁修改：同步块

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

        girlfriend.start();
        you.start();
    }
}

//账户
class Account {
    int money;//余额
    String name;//卡的名字

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款.
//当多个线程操作同一个对象，推荐使用Runnable接口
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(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }
            //模拟延时
            try {
                //sleep可以放大问题的发生性
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额=余额-你取的钱
            account.money = account.money - drawingMoney;

            //你手里的钱
            nowMoney=nowMoney+drawingMoney;

            System.out.println(account.name+"账户余额为："+account.money);
            System.out.println(this.getName()+"手里的钱:"+nowMoney);
        }

    }
}

不安全案例3加锁修改：同步块

//线程不安全的集合
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(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

对于普通同步方法，锁是当前实例对象。 如果有多个实例 那么锁对象必然不同无法实现同步。
对于静态同步方法，锁是当前类的Class对象。有多个实例 但是锁对象是相同的 可以完成同步。
对于同步方法块，锁是Synchonized括号里配置的对象。对象最好是只有一个的 如当前类的 class 是只有一个的 锁对象相同 也能实现同步

CopyOnWriteArrayList集合是线程安全的

死锁

在这里插入图片描述
在这里插入图片描述

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
         new Makeup(0, "灰姑凉").start();
         new Makeup(1, "白雪公主").start();
    }
}

//口红
class Lipstick { }

//镜子
class Mirror { }

class Makeup extends Thread {
    //需要的资源只有一份，用static修饰
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choose;//选择
    String girlName;//使用化妆品的人

    //构造
    Makeup(int choose, String girlName) {
        this.choose = choose;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        makeup();
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的锁
    private void makeup() {
        if (choose == 0) {//获得口红的锁
            synchronized (lipstick) {
                System.out.println(this.girlName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //mirror锁从lipstick锁里面拿出来之后，就解开死锁
            //1s中后想获得镜子
            synchronized(mirror){
                System.out.println(this.girlName+"获得镜子的锁");
            }
        }else
        {
            synchronized (mirror) {
                System.out.println(this.girlName+"获得镜子的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //lipstick锁从mirror锁里面拿出来之后，就解开死锁
            //1s中后想获得口红
            synchronized(lipstick){
                System.out.println(this.girlName+"获得口红的锁");
            }
        }
    }
}

Lock(锁)

在这里插入图片描述
在这里插入图片描述

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2,"q").start();
        new Thread(testLock2,"w").start();
        new Thread(testLock2,"e").start();
    }
}

class TestLock2 implements Runnable {
    int tickNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

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

synchronized和Lock的对比

在这里插入图片描述

线程协作

生产者和消费者问题

线程通信wait（），notify（）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

管程法

在这里插入图片描述

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

//删除这，消费者，产品。缓冲区
public class TestPc {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();//容器
        new Productor(synContainer).start();
        new Consumer(synContainer).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 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[] chilckens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chilcken) {
        //如果容器满了，就需要生产等待,消费者消费
        if (count >= chilckens.length) {
            try {
                this.wait();//生产等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就要丢入产品
        chilckens[count] = chilcken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();//唤醒wait()

    }

    //消费者消费产品
    public synchronized Chicken pop() {
        //判断能否消费
        if (count == 0) {
            //等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chilckens[count];
        //吃完了，通知生产者
        this.notifyAll();
        return chicken;
    }
}

信号灯法

在这里插入图片描述

//测试生产者消费者问题2：信号灯法
public class TestPc2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Wather(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("广告");
            }
        }
    }
}
​```java
//消费者-->观众
class Wather extends Thread {
    Tv tv;

    public Wather(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.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.voice = voice;
        this.flag = !this.flag;
        this.notifyAll();//通知唤醒
    }

    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了:" + voice);
        //通知演员表演
        this.flag = !this.flag;
        this.notifyAll();
    }
}

线程池

在这里插入图片描述
在这里插入图片描述

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

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

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable {

    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值