多线程

多线程

1. 线程简介

任务，进程，线程，多线程

• 多任务

• 现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。
• 多线程
  
• 原来是一条路，慢慢因为车太多了，道路堵塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路堵塞了。
• 普通方法调用和多线程
  
  Process与Thread
• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。
  • 注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu, 即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。
    核心概念
    

2. 线程的创建

三种创建的方式

2.1 Thread类

package 继承Thread类;

/**
 * 创建线程方法一：继承Thread类，重写run方法，调用start开启线程
 * 总结：注意，线程开启不一定立即执行，由CPU调度执行
 */
public class TestThread01 extends Thread{
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();
        //调用start（）方法，开启线程
        testThread01.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程-----");
        }
    }

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 500; i++) {
            System.out.println("我在看代码-----");
        }
    }
}

• 网图下载

package 网图下载;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.net.URL;

/**
 * 练习Thread，实现多线程同步下载图片
 */
public class TestThread extends Thread{
    public static void main(String[] args) {
        TestThread testThread1 = new TestThread("https://img.zcool.cn/community/0152eb5fe716f411013fdcc74c5787.jpg@2o.jpg","1.jpg");
        TestThread testThread2 = new TestThread("https://img.zcool.cn/community/0178f65fe716f411013fdcc72a2990.jpg@2o.jpg","2.jpg");
        TestThread testThread3 = new TestThread("https://img.zcool.cn/community/01395b5fe716f411013ee04d8776c3.jpg@2o.jpg","3.jpg");
        testThread1.start();
        testThread2.start();
        testThread3.start();
    }
    private String url;//网络地址
    private String name;//保存的文件名

    public TestThread(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownload webDownload = new WebDownload();
        try {
            webDownload.Downloader(url,name);
            System.out.println("下载了："+name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//下载器
class WebDownload{
    //下载方法
    public void Downloader(String url,String name) throws Exception {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

2.2 Runnable接口

package 实现Runnable接口;

import 继承Thread类.TestThread01;

public class TestRunnable01 implements Runnable{
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();
        //调用start（）方法，开启线程
        new Thread(testThread01).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程-----");
        }
    }

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 500; i++) {
            System.out.println("我在看代码-----");
        }
    }
}

网图下载

package 实现Runnable接口;

import org.apache.commons.io.FileUtils;

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

public class TestRunnable02 implements Runnable{
    public static void main(String[] args) {
        TestRunnable02 testThread1 = new TestRunnable02("https://img.zcool.cn/community/0152eb5fe716f411013fdcc74c5787.jpg@2o.jpg","1.jpg");
        TestRunnable02 testThread2 = new TestRunnable02("https://img.zcool.cn/community/0178f65fe716f411013fdcc72a2990.jpg@2o.jpg","2.jpg");
        TestRunnable02 testThread3 = new TestRunnable02("https://img.zcool.cn/community/01395b5fe716f411013ee04d8776c3.jpg@2o.jpg","3.jpg");
        new Thread(testThread1).start();
        new Thread(testThread2).start();
        new Thread(testThread3).start();
    }
    private String url;//网络地址
    private String name;//保存的文件名

    public TestRunnable02(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownload webDownload = new WebDownload();
        try {
            webDownload.Downloader(url,name);
            System.out.println("下载了："+name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//下载器
class WebDownload{
    //下载方法
    public void Downloader(String url,String name) throws Exception {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

• 总结
  

龟兔赛跑

package 龟兔赛跑;
/**
 * 模拟龟兔赛跑
 */
public class Race implements Runnable{
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")&&i%50==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag=gameOver(i);
            //如何比赛结束，就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private Boolean gameOver(int step){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }{
            if (step>=100){
            winner=Thread.currentThread().getName();
            System.out.println(winner+"赢得了比赛");
            return true;
            }
        }
        return false;
    }
}

2.3 Callable接口

package 实现Callable接口;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

/**
 * 线程创建方法三：实现Callable接口
 */
public class TestCallable implements Callable<Boolean> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable TestCallable1 = new TestCallable("https://img.zcool.cn/community/0152eb5fe716f411013fdcc74c5787.jpg@2o.jpg","1.jpg");
        TestCallable TestCallable2 = new TestCallable("https://img.zcool.cn/community/0178f65fe716f411013fdcc72a2990.jpg@2o.jpg","2.jpg");
        TestCallable TestCallable3 = new TestCallable("https://img.zcool.cn/community/01395b5fe716f411013ee04d8776c3.jpg@2o.jpg","3.jpg");
        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1=ser.submit(TestCallable1);
        Future<Boolean> r2=ser.submit(TestCallable2);
        Future<Boolean> r3=ser.submit(TestCallable3);
        //获取结果
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdown();
    }
    private String url;//网络地址
    private String name;//保存的文件名

    public TestCallable(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownload webDownload = new WebDownload();
        try {
            webDownload.Downloader(url,name);
            System.out.println("下载了："+name);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }
}
//下载器
class WebDownload{
    //下载方法
    public void Downloader(String url,String name) throws Exception {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

3. 静态代理模式

package 静态代理模式;

/**
 * 静态代理模式总结：
 * 真实对象和代理对象都要实现同一个接口
 * 代理对象要代理真实角色
 * 好处：
 * 代理对象可以做很多真实对象做不到的事情
 * 真实对象专注自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
//        You you = new You();//你要结婚
        new Thread(()-> System.out.println("我爱你")).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 after() {
        System.out.println("结婚之后，付尾款。");
    }

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

4. Lamda表达式

package Lambda表达式;

/**
 * 推到Lambda表达式
 */
public class TestLambda01 {
    //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");
    }
}

package Lambda表达式;

public class TestLambda02 {
    public static void main(String[] args) {
        Ilove love=null;
        //简化括号
        love =(a,b,c)->{
            System.out.println("i love you-->"+a);
            System.out.println("i love you-->"+b);
            System.out.println("i love you-->"+c);
        };
        //总结:
        //lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
        //前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号
    }
}
interface Ilove{
    void love(int a,int b,int c);
}

总结:

• ambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
• 前提是接口为函数式接口
• 多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号

5. 线程状态（五大状态）

5.1 停止线程

package 线程停止;

/**
 * 测试stop
 * 1.建议线程正常停止--->利用次数,不建议死循环。
 * 2。建议使用标志位--->设置一个标志位
 * 3。不要使用stop或者destroy等过时或者JDK不建议使用的方法
 */
public class TestStop implements Runnable{
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main"+i);
            if (i==90){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止");
                break;
            }
        }
    }
    //1. 设置一个标志位
    private Boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("Run....Thread"+i++);
        }
    }
    //设置一个公开的方法停止线程，转换标志符
    public void stop(){
        this.flag=false;
    }
}

5.2 线程休眠

package 线程休眠;

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

public class TestSleep {
    public static void main(String[] args) throws InterruptedException {
        //模拟倒计时
//        Ten();
        //打印当前系统的时间
        Date date=new Date(System.currentTimeMillis());//获取系统当前的时间
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date=new Date(System.currentTimeMillis());//更新当前的时间
        }
    }
    //模拟倒计时
    public static void Ten() throws InterruptedException {
        int time=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(time--);
            if (time<=0){
                break;
            }
        }
    }
}

5.3 线程礼让

package 线程礼让;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

5.4 线程强制执行（Join）

package 线程强制执行Join;

public class TestJoin implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread=new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i==200){
                thread.join();//线程插队
            }
            System.out.println("main"+i);
        }
    }

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

5.5 线程状态观测

package 观测线程状态;

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(1000);
            state=thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

5.6 线程优先级

package 线程的优先级;

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);
        //先设置优先级
        thread1.start();
        thread2.setPriority(1);
        thread2.start();
        thread3.setPriority(4);
        thread3.start();
        thread4.setPriority(8);
        thread4.start();
        thread5.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        thread5.start();
    }
}
class MyPriority implements Runnable{

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

5.7 守护线程（daemon）

package 守护线程;

/**
 * 测试守护线程
 *上帝守护你
 */
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 < 36500; i++) {
            System.out.println("你一生都很快乐的活着");
        }
        System.out.println("========goodbye world================");
    }
}

6. 线程的同步

多个线程操作同一个资源

• 并发
  
• 线程同步
  

• 队列和锁
  

6.1 三大不安全案例

• 不安全的买票

package 三大不安全案例;

/**
 * 不安全的买票
 * 线程不安全，有负数
 */
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 ticket=10;
    Boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                this.buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void buy() throws InterruptedException {
        //判断是否有票
        if (ticket<=0){
            flag=false;
            return;
        }
        //模拟实验
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"抢到了-->"+ticket--);
    }
}

• 不安全的取钱

package 三大不安全案例;

/**
 * 不安全的取钱
 * 两个人去银行取钱，账户
 */
public class UnsafeBunk {
    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;
    }
}
//银行：模拟存款
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;
        }
        //sleep可以放大问题的发生性
        try {
            Thread.sleep(500);
        } 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);

    }
}

• 线程不安全的集合

package 三大不安全案例;

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

/**
 * 线程不安全的集合
 */
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(10);
        System.out.println(list.size());
    }
}

6.2 同步方法及同步块

• 同步方法
  
• 同步方法的弊端
  
• 同步块
  

package 三大不安全案例;

/**
 * 不安全的买票
 * 线程不安全，有负数
 */
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 ticket=10;
    Boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                this.buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized 同步方法,锁的是this
    public synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticket<=0){
            flag=false;
            return;
        }
        //模拟实验
        Thread.sleep(10);
        //买票
        System.out.println(Thread.currentThread().getName()+"抢到了-->"+ticket--);
    }
}

package 三大不安全案例;

/**
 * 不安全的取钱
 * 两个人去银行取钱，账户
 */
public class UnsafeBunk {
    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;
    }
}
//银行：模拟存款
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;
            }
            //sleep可以放大问题的发生性
            try {
                Thread.sleep(500);
            } 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);

        }
    }
}

package 三大不安全案例;

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

/**
 * 线程不安全的集合
 */
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(10);
        System.out.println(list.size());
    }
}

• 测试JUC安全类型的集合（CopyOnWriteArrayList是安全的）

package 三大不安全案例;

import java.util.concurrent.CopyOnWriteArrayList;

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

6.3 死锁

package 死锁;

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");
        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 girlName;//使用化妆的人

    public 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(2000);
                synchronized (lipstick){//一分钟后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

6.4 锁（Lock）

package 锁lLock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock02 testLock = new TestLock02();
        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}
class TestLock02 implements Runnable{
    int ticket=10;
    //定义lock锁 ReentrantLock（可重入的）
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
            while (true){
                try {
                    lock.lock();//加锁
                    if (ticket>0){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(ticket--);
                    }else {
                        break;
                    }
                }finally {
                    //解锁
                    lock.unlock();
                }
            }

    }
}

• synchronized（已同步）与Lock对比
  

7. 线程写作

生产者消费者模式

• 线程通信
  
• 线程通信-分析
  
  

解决方法一（管程法）

package 管程法;

/**
 * 测试：生产者消费者模型-->利用缓冲解决：管程法
 * 生产者，消费者，产品，缓冲区
 */
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++) {
            try {
                container.push(new Chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            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++) {
            try {
                System.out.println("消费了-->"+container.pop().id+"只鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品
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) throws InterruptedException {
        //如果容器满了，就需要等待消费者消费
        if (count==chickens.length){
            //通知消费者消费，生产等待
            this.wait();
        }
        //如果没有满我们就丢入产品
        chickens[count]=chicken;
        count++;
        //可以通知消费者了
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop () throws InterruptedException {
        //判断是否能消费
        if (count==0){
            //等待生产者生产，消费者等待
            this.wait();
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        //可以通知生产者了
        this.notifyAll();
        return chicken;
    }
}

解决方法二（信号灯法）

package 管程法;

/**
 * 测试生产者消费者的问题二：信号灯法，标志位解决
 */
public class TestPC02 {
    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){
                try {
                    this.tv.play("快乐大本营播放中");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    this.tv.play("抖音：记录美好生活");
                } 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++) {
            try {
                this.tv.watch();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品—>节目
class TV {
    //演员表演，观众等待 true
    //观众观看，演员等待 false
    String voice;
    Boolean flag=true;
    //表演
    public synchronized void play(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() throws InterruptedException {
        if (flag){
            this.wait();
        }
        System.out.println("观众观看了->"+voice);
        this.notifyAll();//通知
        this.flag=!this.flag;
    }
}

使用线程池

package 线程池;

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

/**
 * 测试线程池
 */
public class TestPool {
    public static void main(String[] args) {
        //1. 创建服务，创建线程池
        //2. newFixedThreadPool 参数为：线程池大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //关闭
        service.shutdown();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}