多线程 | LxbZone

前言

Java 多线程的内容很重要, 第一遍没学好, 重新梳理总结一下. 把基础内容总结好之后, 会学习JUC并发编程的相关知识, 会一直总结学习下去. 这块内容我还是想深入学习的, 不只是记一些概念性的知识.

线程简介

多线程概念

多线程简化理解为, 一条路上交通很拥挤, 通过开辟多个车道分流, 解决拥堵问题.

单线程调用方法和多线程的区别:

很明显左边的效率低, 右边开辟新线程, 各走各的, 效率高.

线程和进程

在操作系统中运行的程序就是进程, 比如QQ, 播放器, 游戏等

一个进程可以有多个线程, 如视频中同时听到声音, 看到图像, 看弹幕等等

需要注意的是, 程序是指令和数据的有序集合, 是一个静态的概念, 执行程序的一次执行过程叫做进程, 这才是动态的概念

通常在一个进程中可以包含若干个线程, 线程是CPU调度和执行的单位

核心概念:

在程序执行时, 即使没有创建线程, 后台也会有多个线程, 如主线程, gc线程;
main()称之为主线程, 为系统的入口, 用于执行整个程序
对同一份资源操作时, 会存在资源抢夺的问题, 需要加入并发控制
线程会带来额外的开销, 如CPU调度时间, 并发控制开销

线程创建

三种创建方式

Thread方式

Thread类实现了Runnable接口

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

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

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

        // 创建一个线程对象
        TestThread testThread1 = new TestThread();

        // 调用start()方法开启线程
        testThread1.start();
        
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程-----" + i);
        }
    }
}

输出为:

可以看到自定义线程和主线程的输出结果交错显示.

线程不一定立即执行, 由CPU安排调度. 这里如果把start() 方法替换成run() 的话, 就按顺序执行了.

下面写一个从网络同时下载三张图片, 再熟悉一下多线程的使用, 这里因为要处理IO流, 所以导入了commons-io 包

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://justlxb-pic.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20200708232259.png", "1.png"
                );
        TestThread2 t2 = new TestThread2(
                "https://justlxb-pic.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20200708130847.png", "2.png"
                );
        TestThread2 t3 = new TestThread2(
                "https://justlxb-pic.oss-cn-shanghai.aliyuncs.com/46a8eb9c7e647c684c0b92d098727b9b.png", "3.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方法出现问题");
        }
    }
}

来分析一下这段代码, 将下载和存储的功能单独做成一个下载器的类, 这个是主要功能代码, 我们根据创建线程的流程可以知道待会要在重写的run() 方法中调用.

然后来按照流程创建自定义线程类, 要点是继承Thread 类, 重写run() 方法, 然后将功能代码写进run() 方法中.

在主线程中创建三个自定义线程对象, 他们各自负责下载一张图片, 然后使用start() 方法, 输出的结果为:

1
2
3

下载了文件名为: 2.png
下载了文件名为: 3.png
下载了文件名为: 1.png

可以看出多线程的效果.

Runnable方法

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

避免单继承局限性, 灵活方便, 方便同一个对象被多个线程使用

public class TestThread3 implements Runnable {

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

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

        // 创建一个线程对象
        TestThread3 testThread3 = new TestThread3();

//        // 创建线程对象, 通过线程对象来开启我们的线程, 这是个代理
//        Thread thread = new Thread(testThread3);
//        thread.start();
        
        // 简写方式
        new Thread(testThread3).start();

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

输出结果与Thread方法 类似, 不再贴出, 需要注意的是, 在使用start() 方法开启新的线程时通过一个Thread 类的对象调用, 它被称为自定义线程的静态代理.

用实现Runnable接口的方法改写下载网络图片的示例, 只需要改动自定义线程类的名称以及调用方法即可:

1
2
3

new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();

龟兔赛跑小例子

/**
 * 模拟龟兔赛跑
 *
 * @author Lxb0124
 * @create 2020-07-09 13:07
 */
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;
        } 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 方法, 需要抛出异常
创建目标对象

创建执行服务:

1	ExecutorService ser = Executors.newFixedThreadPool(1);

提交执行:

1	Future<Boolean> result1 = ser.submit(t1);

获取结果:
1
boolean r1 = result.get();
关闭服务:
1
ser.shutdownNow;

改写下载网络图片案例:

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://justlxb-pic.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20200708232259.png", "1.png"
        );
        TestCallable t2 = new TestCallable(
                "https://justlxb-pic.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20200708130847.png", "2.png"
        );
        TestCallable t3 = new TestCallable(
                "https://justlxb-pic.oss-cn-shanghai.aliyuncs.com/46a8eb9c7e647c684c0b92d098727b9b.png", "3.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();
    }
}

callable的好处

可以定义返回值
可以抛出异常

并发问题

多个线程同时操作同一个对象

以买火车票为例:

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

分析这段代码的功能, 首先是在自定义线程里设置了共享的资源, 然后开启三个线程对这个资源进行操作. 这里可能会有疑问: 为什么三个线程会对同一个资源进行操作呢? 这要注意我们只创建了一个自定义线程的对象ticket , 然后开启了三次也就是申请了三个代理, 所以只有一个共享资源.

输出结果为:

我们发现了问题: 拿第10张票来说, 三个线程都对其进行了操作, 这就出现了并发的问题.多个线程操作同一个资源的情况下, 线程不安全, 数据紊乱.

为什么龟兔赛跑的例子中没有出现并发问题呢? 这是因为龟兔赛跑中创建的race 对象模拟的是一个赛道, 在整个循环的框架中让线程进来, 所以不会存在冲突的问题.

静态代理

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色

这样做的好处是:

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

下面通过代码深刻了解这一过程:

我们模拟婚庆公司代理举行婚礼的过程

首先创建一个Marry接口:

1
2
3

interface Marry{
    void HappyMarry();
}

定义一个真实对象的类You, 这个是真正要结婚的:

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

    @Override
    public void HappyMarry() {
        System.out.println("xxx要结婚了, 超开心");
    }

}

定义婚庆公司的类:

// 代理角色, 帮助你去结婚
class WeddingCompany implements Marry{

    private Marry target;

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

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        afer();
    }

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

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

}

从这两段代码的对比可以看到, 它们都重写的HappyMarry() 方法, 如果不用婚庆公司的话, 只能实现结婚这一个动作, 使用了代理之后, 不仅原来的功能可以实现(因为传入了You对象), 还可以添加额外的功能.

如果没有用到代理的话, 我们是这样调用的:

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

输出为:

1	xxx要结婚了, 超开心

使用代理之后的话:

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

输出为:

1
2
3

结婚之前布置现场
xxx要结婚了, 超开心
结婚之后收尾款

由婚庆公司的例子可以类比到线程的创建过程, 我们发现线程的创建过程也用到了静态代理的思想

我们将上面创建婚庆公司的对象代码简化一下, 并和线程创建代码写在一起对比:

1 2	new WeddingCompany(new You()).HappyMarry(); new Thread(()-> System.out.println("我爱多线程!")).start();

这里WeddingCompany 和Thread 都是静态代理, 需要传入真实对象, 婚庆公司和You 都实现了Marry 接口; Thread 和自定义线程类都实现了Runnable 接口.

然后最后调用的方法都是代理类中定义的方法.

Lambda表达式

函数式接口

*定义: * 任何接口, 如果只包含唯一一个抽象方法, 那么它就是函数式接口. 例如现在经常接触的Runnable 接口

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

对于函数式接口, 我们可以通过 Lambda 表达式来创建该接口的对象

public class TestLambda1 {

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

// 定义一个函数式接口
interface ILike{
    void lambda();
}

// 实现类
class Like implements ILike{

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

这是一个函数式接口的例子, 先用常规方法调用lambda() 函数

利用静态内部类的方式进行代码优化:

public class TestLambda1 {

    // 静态内部类
    static class Like2 implements ILike{

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

    public static void main(String[] args) {

        Like2 like = new Like2();
        like.lambda();
    }
}

利用局部内部类的方式进行代码优化:

public static void main(String[] args) {

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

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

    Like3 like3 = new Like3();
    like3.lambda();

}

利用匿名内部类进行简化:

public static void main(String[] args) {

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

    like4.lambda();
}

最终, 利用Lambda表达式再进行简化:

public static void main(String[] args) {

    // Lambda表达式
    ILike like5 = ()->{
        System.out.println("i like lambda5.");
    };

    like5.lambda();
}

为什么要使用Lambda 表达式:

避免匿名内部类定义过多
简化代码
去掉了一堆没有意义的代码, 只留下核心的逻辑

带参数的Lambda表达式

public static void main(String[] args) {

    Ilove ilove = (int a)->{
        System.out.println("i love you --->" + a);
    };

    ilove.love(10);
}

interface Ilove {
    void love(int a);
}

进一步简化, 将参数类型和括号都简化掉:

public static void main(String[] args) {

    Ilove ilove = a -> {
        System.out.println("i love you --->" + a);
    };

    ilove.love(10);
}

将花括号都给去掉:

去掉花括号的原因是重写的方法里只有一行代码

public static void main(String[] args) {

    Ilove ilove = a -> System.out.println("i love you --->" + a);

    ilove.love(10);
}

总结

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

线程的五大状态

一些常见的线程方法:

setPriority(int newPriority): 更改线程的优先级
static void sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠
void join(): 等待该线程终止
static void yield(): 暂停当前正在执行的线程对象, 并执行其他线程
void interrupt(): 中断线程, 别用这种方式
boolean isAlive(): 测试线程是否处于活动状态

停止线程

不推荐使用JDK提供的stop(), destroy() 方法. 推荐线程自己停止下来, 可以使用一个标志位进行终止变量当 flag = false, 则终止线程运行.

/**
 * 测试stop
 * 1. 建议线程正常停止, 利用次数, 不建议死循环
 * 2. 建议使用标志位
 * 3. 不要使用stop 或者destroyed方法
 *
 * @author Lxb0124
 * @create 2020-07-10 12:38
 */
public class TestStop implements Runnable {
    // 设置一个标志位
    boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run ... Thread " + i++);
        }
    }

    // 设置一个公开的方法停止线程, 转换标志位
    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("该线程停止了");
            }
        }

    }
}

分析这段代码, 在主线程中开启了自定义线程, 两个线程同时运行, 各自计数, 当主线程记到900时, 将自定义的线程停掉, 结果为:

线程休眠: sleep

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

之前写的三个人抢火车票的代码就应用了网络延时, 可以放大问题的发生性. 下面写一个倒计时的例子:

public static void main(String[] args) {
    // 打印当前系统时间
    Date startTime = new Date(System.currentTimeMillis());

    while (true){
        try {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            startTime = new Date(System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程礼让: yield

礼让线程, 让当前正在执行的线程暂停, 但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度, 礼让不一定成功, 看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() + " 线程停止执行");
    }
}

线程强制执行: join

Join合并线程, 待此线程执行完成后, 再执行其他线程, 其他线程阻塞
可以想象成插队

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 < 500; i++) {
            if (i==50){
                thread.join();
            }
            System.out.println("main " + i);
        }
    }
}

刚开始自定义线程和主线程同时执行, 当主线程计数到50时, 自定义线程强行执行, 直到该线程执行结束主线程再继续执行. 输出结果为:

线程状态观测

通过Thread.State 可以查看线程的状态:

NEW: 尚未启动的线程处于此状态
RUNNABLE: 在Java虚拟机中执行的线程处于此状态
BLOCKED: 被阻塞等待监视器锁定的线程处于此状态
WAITING: 正在等待另一个线程执行特定动作的线程处于此状态
TERMINATED: 已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态, 这些状态是不反映任何操作系统线程状态的虚拟机状态.

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

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

        while (state != Thread.State.TERMINATED) {
            try {
                Thread.sleep(500);
                state = thread.getState();
                System.out.println(state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

分析这段代码, 自定义线程的run() 编写了一个5秒的倒计时, 然后观测这个线程整个过程中的状态. 首先是启动前应该是NEW, 启动了瞬间应该为RUNNABLE, 进入倒计时后应该为TIMED_WAITING, run() 方法跑完之后应该为TERMINATED.

输出结果为:

NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
////////
TERMINATED

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程, 线程调度器按照优先级决定应该调度哪个线程来执行.

线程的优先级用数字表示, 范围从1-10:

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

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

getPriority
setPriority(int xxx)

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

        t1.start();

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

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

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

        t5.setPriority(8);
        t5.start();
    }

}


class MyPriority implements Runnable {

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

输出为:

main --> 5
Thread-3 --> 10
Thread-4 --> 8
Thread-2 --> 4
Thread-0 --> 5
Thread-1 --> 1

需要注意的是, 优先级低只是意味着获得调度的概率低, 并不是优先级低就不会被调用了, 都是看CPU的调度.

守护线程

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

public class TestDaemon {
    
    public static void main(String[] args) {
        God god = new God();
        Youa youa =  new Youa();

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

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

        new Thread(youa).start();

    }
}

// 上帝
class God implements Runnable{

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

// 你
class Youa implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("======goodbye!world!=======");
    }
}

输出为:

线程同步机制

线程同步问题发生在多个线程操作同一个资源时.

并发

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

队列和锁

队列是对线程而言, 是一种排队的机制, 但是只有队列也不行, 还需要资源对象保证安全, 这就是锁 . 队列 + 锁才能保证线程的安全性.

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

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

三大不安全案例

先来分析抢票的过程:

public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "我").start();
        new Thread(station, "你").start();
        new Thread(station, "黄牛").start();
    }
}

class BuyTicket implements Runnable {

    int ticketNums = 10;
    boolean flag = true;

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

    private void buy() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 拿到了 " + ticketNums--);
    }
}

输出为:

我 拿到了 10
你 拿到了 8
黄牛 拿到了 9
我 拿到了 7
你 拿到了 6
黄牛 拿到了 5
我 拿到了 4
你 拿到了 3
黄牛 拿到了 2
我 拿到了 1
你 拿到了 0
黄牛 拿到了 -1

为什么会出现-1呢? 当票还剩一张时, 每个人看到的都是1, 对它进行了重复操作, 所以变成了-1. 这显然说明线程是不安全的.

再来看一个取钱的例子:

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");

        Drawing you = new Drawing(account, 50, "你", 50);
        Drawing wife = new Drawing(account, 100, "girlfriend", 50);

        you.start();
        wife.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, int nowMoney) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;
    }

    //取钱
    @Override
    public void run() {
        if (account.money - drawingMoney < 0) {
            System.out.println("钱不够, 取不了");
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 卡内余额
        account.money = account.money - drawingMoney;
        nowMoney = nowMoney + drawingMoney;

        System.out.println("余额为: " + account.money);
        System.out.println(Thread.currentThread().getName() + " 手里的钱 " + nowMoney);
    }
}

输出为:

余额为: -50
余额为: 0
你 手里的钱 100
girlfriend 手里的钱 150

集合中有不少都是线程不安全的, 比如List:

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

按常理来讲, 列表中应该添加了1000个元素, 但是实际的输出结果为:

可能是因为主线程中的打印操作执行得过早, 还没等线程全部加进去, 那我们添加一个延时, 给足添加的时间:

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

这里给了五秒钟, 足够将所有线程添加到列表中了, 输出结果为:

分析原因是某一时间两个元素添加到了列表的同一位置, 然后覆盖掉了一个.

同步方法

解决上述的不安全案例, 所用的方法就是同步

由于我们可以通过private关键字来保证数据对象只能被方法访问, 所以我们只需要针对方法提出一套机制, 这套机制就是 synchronized 关键字, 它包括两种方法:

synchronized 方法和 synchronized 块.

同步方法: public synchronized void method(int args){}

synchronized 方法控制对”对象”的访问, 每个对象对应一把锁, 每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行, 否则线程会阻塞, 方法一旦执行, 就独占该锁, 直到该方法返回才会释放锁, 后面被阻塞的线程才能获得这个锁, 继续执行.

缺陷: 若将一个大的方法申明为synchronized将会影响效率

在使用synchronize修饰方法时要注意以下几点:

synchronized关键字不能继承.

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
- 在子类方法中加上synchronized关键字:
1
2
3
4
5
6
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}
- 在子类方法中调用父类的同步方法:
1
2
3
4
5
6
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public void method() { super.method(); }
}
在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

修饰一个静态方法

Synchronized也可修饰一个静态方法，用法如下：

1
2
3

public synchronized static void method() {
   // todo
}

我们知道静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public synchronized static void method() {
      for (int i = 0; i < 5; i ++) {
         try {
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public synchronized void run() {
      method();
   }
}

调用代码:

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

结果如下:

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。这与Demo1是不同的。

同步块

同步块: synchronized(Obj) {}

Obj 称之为 同步监视器

Obj 可以是任何对象, 但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器, 因为同步方法的同步监视器就是this, 就是这个对象本身, 或者是 class

同步监视器的执行过程:

第一个线程访问, 锁定同步监视器, 执行其中代码
第二个线程访问, 发现同步监视器被锁定, 无法访问
第一个线程访问完毕, 解锁同步监视器
第二个线程访问, 发现同步监视器没有锁, 然后锁定并访问

对于三个不安全的案例进行修改, 抢票的案例中, 把买票的方法加上关键词 synchronized 即可:

// 同步方法, 锁的是this
    private synchronized void buy() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 拿到了 " + ticketNums--);
    }

输出为:

你 拿到了 10
我 拿到了 9
黄牛 拿到了 8
我 拿到了 7
你 拿到了 6
你 拿到了 5
我 拿到了 4
我 拿到了 3
黄牛 拿到了 2
我 拿到了 1

对于银行取钱的案例进行修改, 使用同步块, 将共用的账户资源作为同步监视器, 然后将取钱的过程放在代码块中:

//取钱
@Override
public void run() {

    synchronized (account){
        if (account.money - drawingMoney < 0) {
            System.out.println("钱不够, 取不了");
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 卡内余额
        account.money = account.money - drawingMoney;
        nowMoney = nowMoney + drawingMoney;

        System.out.println("余额为: " + account.money);
        System.out.println(Thread.currentThread().getName() + " 手里的钱 " + nowMoney);
    }

}

输出结果为:

1
2
3

余额为: 50
你 手里的钱 100
钱不够, 取不了

对不安全的集合案例进行修改, 把list作为同步监视器即可:

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

输出也正常了:

以下两个写法是等价的:

写法一:

public synchronized void method()
{
   // todo
}

写法二:

public void method()
{
   synchronized(this) {
      // todo
   }
}

死锁

案例

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

下面写一个互相抱着对方的锁的例子:

public class TestDeadLock {

    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 + " 获得口红的锁 ");
                }
            }
        }
    }
}

拿g1来说, 因为她抱着口红的锁, 想要镜子的锁, 但是镜子的锁拿不到, 所以同步块一直执行不完, g2也是这样, 相互僵持着, 发生死锁.

死锁的避免方法

产生死锁的四个必要条件:

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

上面的四个必要条件中, 我们只要想办法破其中任意一个或多个条件就可以避免死锁的发生

Lock(锁)

从JDK 5.0 开始, Java 提供了更强大的线程同步机制—-通过显示定义同步锁对象来实现同步, 同步锁使用Lock对象充当.

java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具. 锁提供了对共享资源的独占访问, 每次只能有一个线程对Lock 对象加锁, 线程开始访问共享资源之前应先获得Lock 对象
ReentrantLock 类实现了 Lock, 他拥有与 synchronized 相同的并发性和内存语义, 在实现线程安全的控制中, 比较常用的是ReentrantLock, 可以显式加锁, 释放锁.

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

        new Thread(testLock2, "aaa").start();
        new Thread(testLock2, "bbb").start();
        new Thread(testLock2, "ccc").start();
    }

}

class TestLock2 implements Runnable {
    int ticketNums = 10;

    // lock锁
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try{
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                if (ticketNums > 0) {

                    System.out.println(Thread.currentThread().getName()+ " 抢到了 " + ticketNums--);
                } else {
                    break;
                }
            }finally {
                // 解锁
                lock.unlock();
            }
        }
    }
}

输出为:

aaa 抢到了 10
ccc 抢到了 9
bbb 抢到了 8
bbb 抢到了 7
aaa 抢到了 6
ccc 抢到了 5
bbb 抢到了 4
aaa 抢到了 3
ccc 抢到了 2
ccc 抢到了 1

利用重入锁进行编码的流程为:

class A{
    ReentrantLock lock = new ReentrantLock();
    pubilc void m(){
        lock.lock();
        try{
            //保证线程安全的代码
        }finally{
            lock.unlock();
            // 如果同步代码有异常, 要将unlock()写入finally块中
        }
    }

}

synchronized 与 Lock 的对比

Lock 是显式锁(手动开启和关闭锁, 别忘记关闭), synchronized 是隐式锁, 出了作用域自动释放
Lock 只有代码块锁, synchronize有代码块锁和方法锁
使用Lock锁, JVM将花费较少时间来调度线程, 性能更好. 并且具有更好的扩展性(提供更多的子类)
优先使用顺序:

Lock > 同步代码块(已经进入了方法体, 分配了相应资源) > 同步方法(在方法体之外)

线程协作

生产者消费者模式

应用场景: 生产者和消费者问题

假设仓库中只能存放一件产品, 生产者将生产出来的产品放入仓库, 消费者将仓库中产品取走消费
如果仓库中没有产品, 则生产者将产品放入仓库, 否则停止生产并等待, 直到仓库中的产品被消费者取走为止
如果仓库中放有产品, 则消费者可以将产品取走消费, 否则停止消费并等待, 直到仓库中再次放入产品为止

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

对于生产者, 没有生产产品之前, 要通知消费者等待, 而生产了产品之后, 又需要通知消费者消费
对于消费者, 在消费之后, 要通知生产者已经结束消费, 需要生产新的产品以供消费
在生产者消费者问题中, 仅有 synchronized是不够的
- synchronized可阻止并发更新同一个共享资源, 实现了同步
- synchronized不能用来实现不同线程之间的信息传递(通信)

线程通信

Java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待, 直到其他线程通知, 与sleep不同, 会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程, 优先级高的线程优先调度

注意: 均是Object类的方法, 都只能在同步方法或者同步代码块中使用, 否则会抛出异常IllegalMonitorStateException

管程法

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

生产者: 负责生产数据的模块(可能是方法, 对象, 线程, 进程);
消费者: 负责处理数据的模块(可能是方法, 对象, 线程, 进程);
缓冲区: 消费者不能直接使用生产者的数据, 他们之间有个缓冲区

生产者将生产好的数据放入缓冲区, 消费者从缓冲区拿出数据

写一个例子来理解管程法的过程. 这是一个炸鸡店的例子. 假设库存最大能保留十只鸡, 多于十只则生产者不生产, 生产者线程wait(), 少于零只则消费者不消费,消费者线程wait(). 当消费者成功消费一个炸鸡, 就notifyAll() 一下, 当生产者成功生产一个炸鸡, 就notifyAll() 一下.

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

        new Productor(container).start();
        new Consumer(container).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 {

    // 容器计数器
    int count = 0;

    // 需要一个容器大小
    Chicken[] chickens = new Chicken[10];

    // 生产者放入产品
    public synchronized void push(Chicken chicken) {
        // 如果容器满了, 就要等待消费者消费
        if (count == chickens.length) {
            // 通知消费者消费, 生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果没有满, 我们就需要丢入产品
        chickens[count] = chicken;
        count++;

        // 可以通知消费者消费了
        this.notifyAll();
    }

    // 消费者消费产品
    public synchronized Chicken pop() {
        // 判断能否消费
        if (count == 0) {
            // 等待生产者生产, 消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果可以消费
        Chicken chicken = chickens[count - 1];
        count--;


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

信号灯法

并发协作模型”生产者/ 消费者模式” –> 信号灯法

通过标志位解决

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Watcher(tv).start();
    }
}

// 生产者-- 演员
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("快乐大本营");
            } else {
                this.tv.play("新闻联播");
            }
        }
    }
}

// 消费者-- 观众
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

// 产品-- 节目
class TV {
    // 演员表演, 观众等待 T
    // 观众观看, 演员等待 F
    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;
    }
}

输出结果为:

演员表演了 快乐大本营
观看了 快乐大本营
演员表演了 新闻联播
观看了 新闻联播
演员表演了 快乐大本营
观看了 快乐大本营
演员表演了 新闻联播
观看了 新闻联播
演员表演了 快乐大本营
观看了 快乐大本营
演员表演了 新闻联播
...

线程池

背景: 经常创建和销毁, 使用量特别大的资源, 比如并发情况下的线程, 对性能影响很大
*思路: * 提前创建好多个线程, 放入线程池中, 使用时直接获取, 使用完放回池中. 可以避免频繁创建销毁, 实现重复利用. 类似生活中的公共交通工具
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程, 不需要每次都创建)
- 便于线程管理
  - corePoolSize: 核心池的大小
  - maximumPoolSize: 最大线程数
  - keepAliveTime: 线程没有任务时最多保持多长时间会终止
JDK 5.0 起提供了线程池相关API: ExecutorService 和 Executors
ExecutorServive: 真正的线程池接口. 常见子类ThreadPoolExecutor
- void execute(Runnable command): 执行任务/命令, 没有返回值, 一般用来执行Runnable
- Future submit(Callable task): 执行任务, 有返回值, 一般又来执行Callable
- void shutdown() : 关闭连接池
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());

    }
}

前言

线程简介

多线程概念

线程和进程

线程创建

三种创建方式

Thread方式

Runnable方法

龟兔赛跑小例子

Callable方法(了解即可)

并发问题

静态代理

Lambda表达式

函数式接口

带参数的Lambda表达式

总结

线程的五大状态

停止线程

线程休眠: sleep

线程礼让: yield

线程强制执行: join

线程状态观测

线程优先级

守护线程

线程同步机制

并发

队列 和 锁

三大不安全案例

同步方法

修饰一个静态方法

同步块

死锁

案例

死锁的避免方法

Lock(锁)

synchronized 与 Lock 的对比

线程协作

生产者消费者模式

线程通信

管程法

信号灯法

线程池

队列和锁