Java多线程详解

最新推荐文章于 2024-03-10 19:31:14 发布

Hokwok18

最新推荐文章于 2024-03-10 19:31:14 发布

阅读量233

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_41355222/article/details/123882488

版权

Java 专栏收录该内容

65 篇文章 0 订阅

订阅专栏

1、进程和线程

进程（Process）： 进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
线程（Thread）： 一个进程中可以包含若干个线程，一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
注意： 很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
普通方法调用和多线程

核心概念：

2、线程的创建

三种创建方式：

继承Thread类

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

package kwok.demo01;

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

实现网图下载

先引入commons-io-2.6.jar包：如何引入

package kwok.demo01;

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 t1 = new TestThread2("https://pics5.baidu.com/feed/d53f8794a4c27d1e01cf78c8b3ed4c69dcc43895.jpeg?token=66f090ff0ddccfed80f7093ec6f0d7b1&s=FD81EC1B43A3E4E406ECCDDF030040A3","1.jpg");
        TestThread2 t2 = new TestThread2("https://img1.baidu.com/it/u=17154108,2245864857&fm=26&fmt=auto","2.jpg");
        TestThread2 t3 = new TestThread2("https://img0.baidu.com/it/u=721970865,3312126264&fm=26&fmt=auto&gp=0.jpg","3.jpg");

        // 我们想的：先下载t1,然后下载t2,再下载t3
        // 实际上，是同时进行的，谁先下载完谁结束
        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

定义一个MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

package kwok.demo01;

//创建线程方式2：实现runnble接口，重写run()方法，执行线程需要丢入runnable接口类，调用start()方法
public class TestThread3 implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("我在看代码--"+i);
        }
    }
    public static void main(String[] args) {
        //创建runnbale接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启线程代理
//        Thread thread = new Thread(testThread3);
//        thread.start();

        // 等同于下面
        new Thread(testThread3).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习线程--"+i);
        }
    }
}

3、初识并发问题

继承Thread类

子类继承Thread类具备多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性

实现Runnable接口

实现接口Runnable具有多线程能力
启动线程：传入目标对象+Thread对象.start()
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

package kwok.demo01;

//多个线程同时操作同一个对象
//买火车票的例子
//多个线程操作同一个资源的情况下，线程不安全
public class TestThread4 implements Runnable {
    //票数
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum != 0) {
            if (ticketNum <= 0) break;
            else {
                // 模拟延时
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
            }
        }
    }
    public static void main(String[] args) {
        TestThread4 t4 = new TestThread4();
        new Thread(t4, "小明").start();
        new Thread(t4, "老师").start();
        new Thread(t4, "黄牛").start();
    }
}

4、龟兔赛跑案例

设计思路

1.需要设置两个线程，兔子和乌龟

2.按照故事本身，期间兔子会休息，最终乌龟赢了

3.关于结束的设计，谁先跑满100步，就规定谁赢

3.注意设计逻辑，先跑步，后面接判断或者兔子休息

package kwok.demo01;

// 模拟龟兔赛跑
public class Race implements Runnable {

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; 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;
        }{
            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();
    }
}

5、Callable接口

callable接口模式（了解即可）

Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是
Runnable 不会返回结果，并且无法抛出经过检查的异常。而Callable接口返回结果并且可能抛出异常。实现者定义了一个不带任何参数的叫做 call 的方法。

接口中的方法| 方法摘要 | |
| ———— | ———————————————- |
| V | call() 计算结果，如果无法计算结果，则抛出一个异常。 |

创建线程

通过实现Callable接口创建线程具体步骤：step1：创建一个Callable接口的实现类，需要返回值类型
step2：重写call方法，需要抛出异常
step3：创建目标对象

step4：创建服务 ExecutorService service = Executors.newFixedThreadPool(3)

step5：提交执行 Future r1 = service.submit(new A())

step6：获取结果 boolean rs1 = r1.get();

step7：关闭服务 service.shutdownNow()

示例：

package kwok.demo02;

import kwok.demo01.TestThread2;
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() {
        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://pics5.baidu.com/feed/d53f8794a4c27d1e01cf78c8b3ed4c69dcc43895.jpeg?token=66f090ff0ddccfed80f7093ec6f0d7b1&s=FD81EC1B43A3E4E406ECCDDF030040A3","1.jpg");
        TestCallable t2 = new TestCallable("https://img1.baidu.com/it/u=17154108,2245864857&fm=26&fmt=auto","2.jpg");
        TestCallable t3 = new TestCallable("https://img0.baidu.com/it/u=721970865,3312126264&fm=26&fmt=auto&gp=0.jpg","3.jpg");

        // step4：创建服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        // step5：提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        // step6：获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        // step7：关闭服务
        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方法出现了问题");
        }
    }
}

6、静态代理

真实对象和代理对象都要事先同一个接口
代理对象要代理真实角色
好处：代理对象可以做很多真实对象做不了的事情；真实对象专注做自己的事情

package kwok.staticproxy;

public class StaticProxy {
    public static void main(String[] args) {
        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 before() {
        System.out.println("结婚之前");
    }
    private void after() {
        System.out.println("结婚之后");
    }
}

7、Lambda表达式

避免匿名内部类定义过多
实质属于函数式编程概念

示例1：

package kwok.lambdatest;

//推导lambda表达式
public class TestLambda {
    //2.静态内部类
    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();
        //3.局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();
        //4.匿名内部类,没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();
        //5.lambda简化
        like = () -> System.out.println("I like lambda5");
        like.lambda();
    }
}
//定义一个函数式接口
interface ILike {
    void lambda();
}
//1.实现类
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

示例2：

package kwok.lambdatest;

public class TestLambda2 {
    public static void main(String[] args) {
        Ilove love = null;
        /*// 1.lambda表示简化
        Ilove love = (int a) -> {
            System.out.println("i love u"+a);
        };
        // 简化1：参数类型
        love = (a) -> {
            System.out.println("i love u"+a);
        };*/
        // 简化2：简化括号
//        love = a -> {
//            System.out.println("i love u"+a);
//        };
        // 简化3：去掉花括号
        love = a -> System.out.println("i love u"+a);
        love.love(232);
    }
}

interface Ilove{
    void love(int a);
}
package kwok.lambdatest;

public class TestLambda2 {
    public static void main(String[] args) {
        Ilove love = null;
        /*// 1.lambda表示简化
        Ilove love = (int a,int b) -> {
            System.out.println("i love u"+a);
        };
        // 简化1：参数类型
        love = (a,b) -> {
            System.out.println("i love u"+a);
        };*/
        // 简化2：简化括号
        love = (a,b) -> {
            System.out.println("i love u"+a);
            System.out.println("i love u"+b);
        };
        love.love(232,512);
    }
}

interface Ilove{
    void love(int a,int b);
}

总结：
1.lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行则用代码块包裹。
2.必须是函数式接口，一个接口只能有一个方法。
3.多个参数也可以去掉参数类型，但必须都去掉，加上括号。

8、线程状态

五大状态

停止线程

不推荐使用stop()、destroy()方法【已废弃】
建议使用一个标志位进行终止变量，当flag=false，则终止线程运行。

建议使用一个标志位进行终止变量，当flag=false，则终止线程运行。

package kwok.state;//测试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("线程正在运行-->" + 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);            //调用stop方法切换标志位，让线程停止            if (i == 900) {                testStop.stop();                System.out.println("线程停止");            }        }    }}

线程休眠

sleep指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

package kwok.state;// 模拟网络延时：放大问题的发生性public class TestSleep implements Runnable {    private boolean flag = true;    @Override    public void run() {        int i = 10;        System.out.println("倒计时10s");        while (flag) {            System.out.println(i-- + "s");            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            if (i == 0) {                System.out.println("开炮！！！");                stop();            }        }    }    public void stop() {        this.flag = false;    }    public static void main(String[] args) {        TestSleep testSleep = new TestSleep();        new Thread(testSleep).start();    }}

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
让线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功！看CPU心情

package kwok.state;//测试礼让线程，看CPU心情public class TestYeild {    public static void main(String[] args) {        MyYeild myYeild = new MyYeild();        new Thread(myYeild, "A").start();        new Thread(myYeild, "B").start();    }}class MyYeild implements Runnable {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "-->运行");        Thread.yield();        System.out.println(Thread.currentThread().getName() + "-->停止");    }}

线程合并(插队)

package kwok.state;

//测试Join方法，想象为插队
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; 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);
        }
    }
}

线程状态观测

线程五个状态：新生，就绪，运行，阻塞，死亡

package kwok.state;//观察测试线程状态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);        }    }}

9、线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
现成的优先级用数字表示，范围从1~10
- Thread.MINRIORITY = 1;
- Thread.MAX_RITY = 1;
- Thread.NORN_RITY = 1;
使用以下方式改变或获取优先级
- getPriority(),setPriority(int xxx)

package kwok.state;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);        Thread thread6 = new Thread(myPriority);        //先设置优先级，再启动        thread1.start(); // 0        thread2.setPriority(1);        thread2.start(); // 1        thread3.setPriority(4);        thread3.start(); // 2        thread4.setPriority(10); // 最大优先级        thread4.start(); // 3        thread5.setPriority(-5);        thread5.start();        thread6.setPriority(15);        thread6.start();    }}class MyPriority implements Runnable {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());    }}

10、守护(daemon)线程

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

package kwok.state;

//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread t1 = new Thread(god);
        t1.setDaemon(true);//默认为false表示是用户线程，正常的线程都是用户线程
        t1.start();
        Thread t2 = new Thread(you);
        t2.start();
        Thread.State state = t2.getState();
        if (state == Thread.State.TERMINATED) god.stop();
    }
}
//上帝
class God implements Runnable {
    private boolean flag = true;
    @Override
    public void run() {
        while (flag) {
            System.out.println("上帝保佑你");
        }
    }
    public void stop() {
        this.flag = false;
    }
}
//你
class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("我活了" + i + "天");
        }
        System.out.println("==GoodBye World==");
    }
}

11、线程同步问题及解决

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

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

线程同步形成条件：队列+锁

由于同一进程的多个线程共享同一块从存储空间，在带来方便的同时，也带来了访问冲突的问题，为了保证数据在方法中北方为师的正确性，在访问时加入锁机制synchronized，在一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，但存在以下问题：

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

并发问题案例：不安全的银行

package kwok.syn;public class UnsafeBank {    public static void main(String[] args) {        Account account = new Account(100_0000, "基金");        Drawing you = new Drawing(account, 50_0000, "你");        Drawing girlFriend = new Drawing(account, 100_0000, "女朋友");        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(this.getName() + "Not enough money!");            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);    }}

同步方法及同步块

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是sunchronized关键字，它包括两种用法：synchronized方法和synchronized块。
- 同步方法：public synchronized void method(int args) {}
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一石知行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
- 缺陷：若将一个大的方法申明为synchronized将会影响效率

synchronized默认锁this，是这个类本身，所以如果要对Account上锁则需要使用同步块:

同步块：synchronized(Obj){}
Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，是对象本身，或者是class
同步监视器执行过程
1.第一个线程访问，锁定同步监视器，执行其中代码
2.第二个线程访问，发现同步监视器被锁定，无法访问
3.第一个线程访问完毕，解锁同步监视器
4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

package kwok.syn;public class UnsafeBank {    public static void main(String[] args) {        Account account = new Account(100_0000, "基金");        Drawing you = new Drawing(account, 50_0000, "你");        Drawing girlFriend = new Drawing(account, 100_0000, "女朋友");        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(this.getName() + "Not enough money!");                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);        }    }}

JUC包有安全类型，跟锁住了一样

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”，就可能发生“死锁”问题。

原代码：

package kwok.lock;

//死锁：多个线程互相拥有对方需要的资源，然后形成僵持
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 + "获得口红的锁");
                }
            }
        }
    }
}

优化后代码：

package kwok.lock;

//死锁：多个线程互相拥有对方需要的资源，然后形成僵持
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 + "获得口红的锁");
            }
        }
    }
}

产生死锁的四个必要条件：
1.互斥条件：一个资源每次只能被一个进程使用
2.请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源保持不放。
3.不剥夺条件：进程已获得的资源，在位置用完之前，不能强行剥夺。
4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显示顶底同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，县城开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁

package kwok.lock;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 {    private int ticketNum = 10;    //定义lock锁    private final ReentrantLock lock = new ReentrantLock();    @Override    public void run() {        while (true) {            try {                lock.lock();//加锁                if (ticketNum > 0) {                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(ticketNum--);                } else break;            } catch (Exception e) {                e.printStackTrace();            } finally {                lock.unlock();            }        }    }}

synchronized与Lock的对比

Lock是显示锁(手动开启和关闭锁，不能忘记关闭锁)synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多子类)
优先使用顺序：
- Lock -> 同步代码块(已经进入了方法体，分配了相应资源) -> 同步方法(在方法体之外)

12、线程协作(生产者消费者模式)

应用场景：生产者和消费者问题
- 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止
- 如果仓库中方有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止

这是一个线程同步问题，生产参这和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

管程法

并发协作模型“生产者/消费者模式”—>管程法

生产者：负责生产数据的模块(可能是方法，对象，线程，进程)；
消费者：负责处理数据的模块(可能是方法，对象，线程，进程)；
缓冲区：消费者不能直接使用生产者的数据，它们之间有个“缓冲区”
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

package kwok.lock;

//测试：生产者消费者模型-->利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}
//生产者
class Producer extends Thread {
    SynContainer container;
    public Producer(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;
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    Chicken[] chickens = new Chicken[10];//容器大小
    int count = 0;//容器计数器
    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //如果容器满了，等待消费者消费
        while (count >= chickens.length) {
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果容器没满，需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop() {
        //判断能否消费
        while (count == 0) {
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //吃完了，通知消费者生产
        this.notifyAll();
        return chicken;
    }
}

信号灯法

package kwok.lock;

//测试：生产者消费者模型-->利用缓冲区解决：信号灯法
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 = new 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("看B站");
            } else {
                this.tv.play("看小说");
            }
        }
    }
}
//消费者-->观众
class Watcher extends Thread {
    TV tv = new 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;
    }
}

13、线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的资源，不需要每次都构建)
- 便于线程管理
- - corePoolSize：核心池的大小
  - maximumPoolSize：最大线程数
- - keepAliveTime：线程没有任务时最多保持多长时间后会终止

使用线程池

JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Tunnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- Futuresubmit(Callabletask)：执行任务，有返回值，一般用来执行Callable
- void shutdown()：关闭线程池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

package kwok.lock;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池
        //newFixedThreadPool参数为线程池大小
        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());
    }
}

Hokwok18

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程详解

1、进程和线程进程（Process）：进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位线程（Thread）：一个进程中可以包含若干个线程，一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。普通方法调用和多线程核心概念：
复制链接

扫一扫