06Java多线程---超详细回顾、Thread、Runnable、Cakkable、Lambda、锁Lock和synchronized等

最新推荐文章于 2023-02-24 21:30:32 发布

在下宝龙、

最新推荐文章于 2023-02-24 21:30:32 发布

阅读量298

点赞数 1

分类专栏： Java多线程文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/BlackNamePlate/article/details/115276040

版权

Java多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

线程简介

任务

例子边吃饭边玩手机，边开车边打电话都算多任务

看起来多个任务在做，其实本质上大脑在同一时间只做了一件事情

多线程

例子原来是一条路，慢慢因为车太多了道路拥塞，所以加了多个车道。

普通方法调用和多线程

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uizjFcnu-1616892448805)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210325084806369.png)]$

程序进程线程

在操作系统中运行的程序就是进程，比如你的QQ，游戏等
一个进程里会有多个线程，比如视频同时显示图像，声音，字幕

程序是指令和数据的有序集合，其本身没有任何运行概念，是一个静态的概念
进程则是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位
一个进程可以包含多个线程，线程是CPU调度和执行的单位 例如main函数就是主线程

注意！

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8EnspJQf-1616892448808)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210325085302783.png)]$

核心概念

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-leXGmXVu-1616892448809)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210325085842160.png)]$

线程创建三种方式

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V1T6UjRW-1616892448811)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210325090110763.png)]$

Thread

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

线程开启不一定立即执行，由CPU调度执行

package com.ybl.demo1;
//继承thread类 重写run方法，调用start
public class TestThread extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread testThread = new TestThread();
        //调用start()方法开启
        // 调用run()的话就先执行run()
        testThread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学多线程---"+i);
        }
    }
}

#运行结果，两个线程同时执行
我在学多线程---0
我在看代码---0
我在学多线程---1
我在学多线程---2
我在学多线程---3
我在学多线程---4
我在学多线程---5
我在学多线程---6
我在学多线程---7
我在学多线程---8
我在学多线程---9
我在学多线程---10
我在学多线程---11
我在学多线程---12
我在学多线程---13
我在学多线程---14
我在学多线程---15
我在学多线程---16
我在学多线程---17
我在学多线程---18
我在学多线程---19
我在看代码---1
我在看代码---2
我在看代码---3
我在看代码---4
我在看代码---5
我在看代码---6
我在看代码---7
我在看代码---8
我在看代码---9
我在看代码---10
我在看代码---11
我在看代码---12
我在看代码---13
我在看代码---14
我在看代码---15
我在看代码---16
我在看代码---17
我在看代码---18
我在看代码---19

多线程实现网图下载

先下载commons IO jar包（百度搜索commons IO
创建一个lib目录，复制进去jar包

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZxkBjuf0-1616892448812)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327113436959.png)]$

右键添加为lib

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XFlFRo8p-1616892448814)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327113507777.png)]$

代码

package com.ybl.demo1;

import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread {
    private String url;
    private String name;

    public TestThread2(String url,String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);;
        System.out.println("下载了文件名"+name);
    }

    public static void main(String[] args) {
        TestThread2 testThread2 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","2.jpg");
        TestThread2 testThread3 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","3.jpg");
        TestThread2 testThread4 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","4.jpg");
        testThread2.start();
        testThread3.start();
        testThread4.start();
    }
}

class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Runnable 接口实现

推荐使用runnable接口

该方法便面了单继承的局限性，灵活方便，方便同一个对象被多个线程使用

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d4KYx5fW-1616892448815)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327120221606.png)]$

//创建线程方式2：实现runable接口，重现run方法，执行线程需要runable接口实现类，调用start方法
public class TestThread3 implements Runnable {
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnablr接口实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread =new Thread(testThread3); //把实现类对象丢进来

        thread.start();

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

}

初识并发问题

//发现问题，多个线程操作同意给资源的情况下，线程不安阿全，数据紊乱

//发现问题，多个线程操作同意给资源的情况下，线程不安阿全，数据紊乱
public class TestThread4 implements  Runnable{
    int tickeNums=10; //操作同一个对象，所以可以用一个计票来技术。
    @Override
    public void run() {
        while (true){   //Thread.currentThread().getName() 获得当前线程的名字
            if(tickeNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+tickeNums--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();//创建了一个实现
        new Thread(testThread4,"小猫").start();
        new Thread(testThread4,"小狗").start();
        new Thread(testThread4,"小牛").start();
        
    }
}
小猫拿到了第10票
小狗拿到了第8票
小牛拿到了第9票
小猫拿到了第7票
小狗拿到了第6票 // 6号票被拿了两次
小牛拿到了第6票
小狗拿到了第5票
小牛拿到了第4票
小猫拿到了第3票
小狗拿到了第2票
小牛拿到了第1票
小猫拿到了第0票
Process finished with exit code 0

龟兔赛跑多线程

package com.ybl.demo1;

public class Race implements Runnable{
    private  static String winner;
    @Override
    public void run() {

        for (int i = 0; i < 101; i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否比赛
            boolean flag=gameOver(i);
            if(flag){
                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();
    }
}

实现Callable接口（了解即可

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务ExecutorService ser=Executors.newFixedThreadPool(1);
提交执行Future<Boolean> result1=ser.submit(t1);
获取结果boolean r1=result1.get()
关闭服务ser.shutdownNow();

package com.ybl.demo1;

import java.util.concurrent.*;

/*
    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;
    }
    //下载图片线程的执行体
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);;
        System.out.println("下载了文件名"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","2.jpg");
        TestCallable t2 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","3.jpg");
        TestCallable t3 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","4.jpg");
        //1. 创建执行服务` 创建了一个线程池 有三个线程
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //2. 提交执行`
        Future<Boolean> result1=ser.submit(t1);
        Future<Boolean> result2=ser.submit(t2);
        Future<Boolean> result3=ser.submit(t3);
        //3. 获取结果`
        boolean rs1=result1.get();
        boolean rs2=result2.get();
        boolean rs3=result3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //4.关闭服务`
        ser.shutdownNow();
    }
}

静态代理-Runable底部实现原理

代理：就是别人帮你做事情

从静态代理方面来理解 Thread和Runnable接口和实现Runnable接口的类之间的关系

package com.ybl.demo2;
//静态代理模式总结
/*
真实对象和代理对象都要实现同一个接口
代理对象和代理真实角色
//好处
代理对象可以做很对真实对象做不了的事情
真实对象专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
//        You you = new You();
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我要结婚了");
            }
        }).start();
        
        new WeddingCompany(new You()).HappyMarry();
        //其实这个例子和thread 相似，，thread和wedcompany都实现了一个接口，然后you和实现runnable接口的类，然后通过代理来调用方法
    }
}
interface Marry{
    //人间四大喜事
        //久旱逢甘霖
        //他乡遇故知
        //洞房花烛夜
        //金榜题名时
    void HappyMarry();
}
//真实角色，你去结婚 对应实现runnable接口的类
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("我结婚了");
    }
}
//代理角色 帮助你结婚 对应Thread
class WeddingCompany implements Marry{
    //代理真实目标角色
    private Marry target;

    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("结婚之前布置现场");
    }
}

Lambda表达式

避免匿名内部类定义过多

 new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我要结婚了");
            }
        }).start();
//可以写成
new Thread(()->System.out.println("我要结婚了")).start();

函数式接口

定义：

任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口

public interface Runnable{
    public abstract void run();
}

对于函数式接口，我们可以用lambda表达式来创建该接口对象（接口实例化 new一个它的实现类

package com.ybl.demo3;

public class TestLambda1 {
    //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=(int a)->{
            System.out.println("i like lambda5"+a);
        };
        like.lambda(2);
        like=(a)->{
            System.out.println("i like lambda5"+a);
        };
       	like=a->{
            System.out.println("i like lambda5"+a);
        };
        like=a->System.out.println("i like lambda5"+a);
        
       
    }
}


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

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

简化lambda 表达式

 
        like=(int a)->{//1
            System.out.println("i like lambda5"+a);
        };
        like.lambda(2);
 		like=(a)->{//2
            System.out.println("i like lambda5"+a);
        };
       	like=a->{//3
            System.out.println("i like lambda5"+a);
        };
			//4
        like=a->System.out.println("i like lambda5"+a);

lambda表达式只有参数和行数为1行才能简化成这样
多个参数也可以去掉参数类型，但必须加括号，

线程的五大状态

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5MM32QmA-1616892448816)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327133916475.png)]$

创建状态 new Thread()
启动线程调用start() 就绪状态
获得CPU之后进入运行状态
sleep()等方法进入阻塞状态
阻塞解除后进入就绪状态
正常执行完之后进入死亡状态

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cFUc9UgU-1616892448817)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327134242813.png)]$

线程方法

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UenL1C4g-1616892448818)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327134404830.png)]$

线程停止

一旦线程死亡之后就不能再次启动

package com.ybl.state;
/*
1.建议线程正常停止---->利用次数，不建议死循环
2.使用标志位-->设置一个flag
3.不要使用stop或者destroy 等过时方法
 */
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++) {
            if(i==900){
                //调用stop方法切换标志位 让线程停止
                testSTop.stop();
                System.out.println("线程停止了");
            }
        }

    }
}

线程休眠

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eMKvAyEE-1616892448818)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327135426257.png)]$

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

//模拟倒计时
public class TestSleep2 {
    public static void tenDown() throws InterruptedException {
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }

    public static void main(String[] args) {
        //打印系统当前时间
        Date startTime= new Date(System.currentTimeMillis());
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(new SimpleDateFormat("HH:MM:ss").format(startTime));
            startTime=new Date(System.currentTimeMillis());
        }
    }
}
14:03:02
14:03:03
14:03:04
14:03:05
14:03:06
14:03:07
14:03:08
14:03:09
14:03:10

线程礼让

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDWEX6XC-1616892448819)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327140628966.png)]$

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

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

Join 插队

package com.ybl.state;

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 < 1000; i++) {
            if (i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

观测线程状态

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-amCLKd4v-1616892448820)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327154626524.png)]$

package com.ybl.state;

import com.sun.javaws.IconUtil;

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);
        //观察启动后
        thread.start();
        state=thread.getState();
        System.out.println(state);
        while(state!=Thread.State.TERMINATED){
            //只要线程不终止 就一直输出状态
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
        }
        //错误 死亡之后的进程不能再次启动
        //thread.start();
    }
}

一旦线程死亡之后就不能再次启动

线程优先级

线程优先级用数字表示，范围从1~10

Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=10;
Thread.Norm_Priority=5;

使用以下方式改变或获取优先级

getPriority()
setPriority(int xxx)

优先级的设定建议在start()调度前

优先级低知识意味着获得调度的概率低，并不是优先级低就不会被调用了，这都看CPU;

package com.ybl.state;

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 main也是5
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
    }
}
class Mypriority implements Runnable{

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

守护线程 daemon

线程分为用户线程和守护线程
虚拟机确保用户线程执行完毕 —main
虚拟机不用等待守护线程执行完毕
- 如后台记录操作日志，监控内存，垃圾回收

package com.ybl.state;

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  You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 365; i++) {
            System.out.println("你开心的活着");
        }
        System.out.println("========good bye world========");
    }
}
class  God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

线程同步

并发：同一个对象被多个线程同时操作

多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

队列和锁

线程同步需要队列和锁，一个例子就是厕所，你上厕所需要排队形成了队列，进入厕所之后锁上门，形成了锁，sleep()的时候不会释放锁。

为了保证数据在方法中被访问的正确性，在访问的时候加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：

降低性能，一个线程持有锁会导致其他所有此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FEmDZkxQ-1616892448821)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327205019343.png)]$

package com.ybl.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 < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size()); //打印出来998说明 有线程重复操作List，而且List是不安全的
    }
}

同步方法

synchronized包括两种用法

synchronized方法和synchronized块

public synchronized void method(int arge){}

synchronized 方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到改方法返回才释放锁。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xlAdW0Is-1616892448822)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327210417494.png)]$

需要注意的是 synchronized方法默认锁当前方法的对象就是this，而synchronized块可以锁其他对象，这个块锁的对象就是变化的量，需要增删改的对象

车票变化类ticket中要操作的属性ticketnum就在run（）方法的类中，这时候锁就直接锁掉了，而银行Bank中要操作的属性account在别的类中，run在Bank中，这时候锁run没有用，因为操作的对象是account而不是bank

package com.ybl.syn;

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 < 1000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        //注意这里要sleep一下，因为不加的话主线程提前跑完，其他线程还在运行中，导致现实的结果小于1000
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

另外一种写法，引用安全的包

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的几何
public class TsetJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; 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.ybl.syn;

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

class Lipstick{

}
class Mirror{

}
class  Makeup extends Thread{
    //需要的资源只有一份，用static来表示
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror =new Mirror();
    int choice;
    String grilName;

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

    @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.grilName+"获得口号的锁");
                Thread.sleep(1000);
                synchronized (mirror){
                    System.out.println(this.grilName+"获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.grilName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){
                    System.out.println(this.grilName+"获得口红的锁");
                }
            }
        }
    }
}
//改例子中，A在获得口红资源之后 不释放的情况下，去占有另外一个资源，会导致死锁，所以把里面的synchronized放到外面来

产生死锁的四个条件

互斥条件：一个资源每次只能被一个线程使用
请求与保持条件：一个线程因请求资源而阻塞时，对以获得的资源保持不妨
不剥夺条件：线程以获得资源，在未使用完之前，不能强行剥夺
循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系

Lock锁

从JDK5.0 开始，Java提供了更强大的线程同步机制–通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当

ReentrantLock类实现了Lock

package com.ybl.syn;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 a= new TestLock2();

        new Thread(a,"A").start();
        new Thread(a,"B").start();
        new Thread(a,"C").start();
    }
}

class TestLock2 implements Runnable{
    int ticketNums=1000;
    //定义 lock锁
    private ReentrantLock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){

            try {
                lock.lock(); //显示的加锁
                if(ticketNums>0){
                    System.out.println(Thread.currentThread().getName()+"---"+ticketNums--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();
            }


        }
    }
}

Lock锁和synchronized对比

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8rbgiXPV-1616892448823)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327220019503.png)]$

线程协作 --生产者消费者

问题描述

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkiNOqY1-1616892448824)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327220535254.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wpWBmbUy-1616892448826)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327220725949.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LgoBjIg3-1616892448827)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327220920318.png)]$

解决方式一

管程法

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tg7zZmG1-1616892448827)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327221049010.png)]$

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

class  Product extends Thread{
    SynContainer container;

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(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; //产品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;

        //可以通知消费者消费了
        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;
    }
}

解决方式二

信号灯法—通过一个标志位flag来解决

线程池

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xsGcHTRi-1616892448828)(D:\ADeskTop\大三下学期\JAVA\Java多线程\06Java多线程.assets\image-20210327224314657.png)]$

package com.ybl;

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.创建服务 创建线程池
        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());
    }
}
pool-1-thread-1
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3

Process finished with exit code 0