当前位置：移动技术网 > IT编程>开发语言>Java > 荐一文搞懂Java多线程

荐一文搞懂Java多线程

2020年07月22日 | 移动技术网IT编程 | 我要评论

文章目录

一、基本概念：程序、进程、线程
二、线程的创建和使用

方式一：继承于Thread类
方式二：实现Runnable接口
方式三：实现Callable接口
方式四：使用线程池

三、线程的生命周期
四、线程的同步

方式一：同步代码块
方式二：同步方法
线程安全的单例模式之懒汉式
线程的死锁问题
方式三：Lock锁

五、线程的通信

一、基本概念：程序、进程、线程

要了解线程，首先得先了解程序和进程

程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。
进程（process）是程序的一次执行过程，或者是正在运行的一个程序，是一个动态的过程：有他自身的产生、存在和消亡的过程（生命周期）
》如：运行中的QQ，运行中的MP3播放器
》程序是静态的，进程是动态的
》进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程（thread），进程可进一步细化为线程，是一个程序内部的一条执行路径
》若一个进程同一时间并行执行多个线程，就是支持多线程的
》线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
》一个进程中的多个线程共享相同的内存单元/内存地址空间→他们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简洁、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患
单核CPU和多核CPU的理解
》单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有很对车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员，如果有人不想交钱，那么收费人员就可以把它“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，所以感觉不出来
》如果是多核的话，才能更好的发挥多线程的效率（现在的服务器都是多核的）
》一个Java应用程序java.exe，其实至少有3个线程：main()主程序，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程
并行与并发
》并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
》并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事
使用多线程的优点
》背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
》提高应用程序的响应。对图形化界面更有意义，可增强用户体验
》提高计算机系统CPU的利用率
》改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程
》程序需要同时执行两个或多个任务
》程序需要实现一些等待的任务，如用户输入、文本读写操作、网络操作、搜索等
》需要一些后台运行的程序时

二、线程的创建和使用

在这里插入图片描述

多线程的创建

方式一：继承于Thread类

创建一个继承于Thread类的子类
重写Thread类的run()→将此线程执行的操作重写在run()中
创建Thread类的子类对象
通过此对象调用start()：
》start()作用：①启动当前线程②调用当前线程的run()
》注意事项：①不能在没有调用start()的情况下，直接run()启动线程
②不能调用了一次start()之后，再去调用start()，如有需要，再去new一个对象

例子：遍历100以内所有的偶数

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()→将此线程执行的操作重写在run()中
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类对象
        MyThread t1 = new MyThread();

        //4. 通过此对象调用start()：
        //start()作用①启动当前线程②调用当前线程的run()

        t1.start();
		//如下操作仍在main线程中执行
        System.out.println("hello world");
    }
}

此多线程的工作原理如下：（字有点丑）
在这里插入图片描述

改进：
既然创建的MyThread的对象只用过一次，后面就没有用了，那就可以用匿名的方式——创建Thread 的匿名子类

new MyThread(){
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}.start();

完整代码如下：

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()→将此线程执行的操作重写在run()中
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
//        //3. 创建Thread类的子类对象
//        MyThread t1 = new MyThread();
//
//        //4. 通过此对象调用start()
//        t1.start();
        new MyThread(){
            @Override
            public void run(){
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0){
                        System.out.println(i);
                    }
                }
            }
        }.start();
        System.out.println("hello world");
    }
}

Thread的常用方法
在这里插入图片描述

线程的优先级

例2：创建3个窗口卖票，总票数为100张（继承Thread方式）

class Window extends Thread{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if (ticket>0){
                System.out.println(getName()+":卖票，票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

此时输出为：
在这里插入图片描述
注意此时的程序是每个窗口各卖100张票，总和为300张了，这不对。只需做出小修改，将ticket加一个static即可。

private static int ticket = 100;

输出结果：
在这里插入图片描述
可以看到，除了100以外（之后会讲解决线程的安全问题，这里先忽略），其他票号都是只出现了一次

方式二：实现Runnable接口

创建一个实现了Runnable接口的类
实现类去实现Runnable中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()：①启动线程②调用当前线程的run()→调用了Runnable类型的target的run()

例子：遍历100以内所有的偶数

// 1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start()：
        // ①启动线程②调用当前线程的run()→调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

输出结果：
在这里插入图片描述
例2：创建3个窗口卖票，总票数为100张（实现Runnable接口的方式）

class Window1 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                ticket--;
            }
            else{
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

结果如下：

在这里插入图片描述
可以看到，ticket并没有加static，为什么就可以实现3个窗口卖100张票呢？——因为我们只造了一个对象，这一个对象放到3个构造器中，说明这3个线程都是用的同一个new的window，所以ticket自然就是同一个ticket

比较创建线程的两种方式：
开发中，优先选择Runnable接口的方式
原因：
①实现的方式没有类的单继承的局限性，例如3个窗口卖票的例子，Window继承了Thread之后，就没法再继承其他类了（在Java中，继承可是稀缺资源）
②实现的方式更适合来处理多个线程有共享数据的情况

联系：public class Thread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

方式三：实现Callable接口

在这里插入图片描述

步骤：

创建一个实现Callable的实现类
实现call方法，将此线程需要执行的操作声明在call()中
创建Callable接口实现类的对象
将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
如有需要，返回Callable中call方法的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <=100 ; i++) {
            if(i%2==0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.如有需要，返回Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

call()可以有返回值
call()可以抛出异常，被外面的操作捕获，获取异常信息
Callable是支持泛型的

方式四：使用线程池

在这里插入图片描述

步骤：

提供指定线程数量的线程池
执行指定线程的操作，需要提供实现Runnable接口（或Callable接口）实现类的对象
关闭连接池

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

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定线程的操作，需要提供实现Runnable接口（或Callable接口）实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());
//        service.submit(Callable callable);//适合适用于Callable
        //3.关闭连接池
        service.shutdown();

    }
}

三、线程的生命周期

在这里插入图片描述

四、线程的同步

为什么要进行线程的同步呢？——①多个线程执行的不确定性引起执行结果的不稳定 ②多个线程对数据的共享，会造成操作的不完整性，会破坏数据
举个例子：假如一个账户有3000元，我去取2000元，恰巧就在我输完账户密码等待系统响应的时候，我媳妇也输完账户密码，媳妇她也取2000元，那这个时候系统就会出现问题了，是给我和媳妇各自都吐出2000元吗？还是显示出错呢？
在这里插入图片描述
这就是线程的安全问题，那么要怎么解决这种线程的安全问题呢？——线程的同步

在这里插入图片描述

在这里插入图片描述
还是举卖票的例子：创建三个窗口卖票，总票数为100张

问题：卖票过程中，出现了重票、错票——出现了线程安全的问题
问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来（相当于上了把锁），直到线程a操作完ticket时，其他线程才可以开始操作ticket，这种情况即使线程a出现了阻塞，也不能改变
在Java中，我们通过同步机制，来解决线程安全问题
局限性：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低

方式一：同步代码块

synchronized(同步监视器){
	//需要同步的代码
}

说明：
①操作共享数据的代码，即为需要被同步的代码
②共享数据：多个线程共同操作的变量，比如：ticket就是共享数据
③同步监视器，俗称：锁。任何类的对象都可以来充当锁
要求：多个线程必须共用同一把锁

使用实现Runnable接口的方式
可以看到没进行同步的代码为：

class Window1 implements Runnable{
    private int ticket = 100;

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

                System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                ticket--;
            }
            else{
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果为：可以看出是有错票和重票的
在这里插入图片描述
这里再加上synchronized ，并且以obj为锁

class Window1 implements Runnable{
    Object obj = new Object();
    private int ticket = 100;

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

                    System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果如下，可以看到已经消除了错票和重票
在这里插入图片描述
改进：改进：这时候想，每次都需要再去new一个对象来做锁吗？有没有什么简单的对象可用只要保证唯一就行——当前对象this

synchronized (this)

因为调用run()方法的对象是this，而方式是在Window1中定义的，所以Window1的对象就是this，我们自始至终只造过一个Window1对象w，所以this是唯一的

使用继承Thread类的方式：
可以看到没进行同步的代码为：

class Window extends Thread{
    Object obj = new Object();
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if (ticket>0){
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(getName()+":卖票，票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果为：可以看到有错票和重票
在这里插入图片描述

现在我们依葫芦画瓢修改代码，加上synchronized使其同步：

class Window extends Thread{
    private Object obj = new Object();
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            synchronized (obj){
                if (ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(getName()+":卖票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：可以看出并没有解决错票和重票
在这里插入图片描述
原因是我们在main方法中，new了三个Window对象，而每new一次对象，就会新new一个Object对象obj，这里就违反了多个线程必须共用同一把锁这一要求

解决办法：在new 的obj对象前加一个static即可

private static Object obj = new Object();

可以看到运行结果为：成功

在这里插入图片描述
改进：我们依照实现Runnable接口的方式，用this当锁，这里是不行的，因为这里new了三个Window对象，那要怎么办呢？？？——每一个类都是一个对象，使用户当前类来充当同步监视器，并且这个类只会加载一次

synchronized (Window.class)

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明成同步的

使用同步方法解决实现Runnable的线程安全问题

首先，将操作共享数据的代码抽取出来，形成一个新的方法，并且定义此方法为同步方法（并且把else–break去掉）
此时，这里的同步监视器为this

private synchronized void show(){//同步监视器为this
    if (ticket>0){
        try{
            Thread.sleep(100);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
        ticket--;
    }
}

完整代码为：

class Window2 implements Runnable{
    //Object obj = new Object();
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }
    private synchronized void show(){//同步监视器为this
        if (ticket>0){
            try{
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
            ticket--;
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

使用同步方法解决继承Thread类的线程安全问题

首先，也是将操作共享数据的代码抽取出来，形成一个新的方法，并且定义为同步方法，而且要变成静态方法（方法内部方法也有变成静态的），因为如果不是静态的方法，那么将会被调用多次，此时同步监视器为Window3.class

class Window3 extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }
    private static synchronized void show(){//同步监视器为Window3.class
        if (ticket>0){
            try{
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 t1 = new Window3();
        Window3 t2 = new Window3();
        Window3 t3 = new Window3();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

关于同步方法的总结：
①同步方法仍涉及到同步监视器，只是不需要我们显式地声明
②非静态的同步方法，同步监视器为：this
静态的同步方法：同步监视器为：当前类本身

线程安全的单例模式之懒汉式

class Bank{
    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
//        //方式一：效率稍差
//        synchronized (Bank.class){
//            if (instance == null){
//                instance = new Bank();
//            }
//            return instance;
//        }

        //方式二：效率更高
        if (instance == null){
            synchronized (Bank.class){
                if (instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

线程的死锁问题

死锁：
》不同的线程分别占用对方需要的的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决：
①专门的算法、原则 ②尽量减少同步资源的定义 ③尽量避免嵌套同步

例：下面代码是有可能出现死锁的，只不过出现死锁的概率比较小

public class ThreadTest2 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }){

        }.start();
    }
}

运行得出的一个结果为：
在这里插入图片描述
下面我们给代码加点东西（使用sleep），让其出现死锁的概率变高。

public class ThreadTest2 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }){

        }.start();
    }
}

现在就运行得不出结果了，出现死锁
是为什么呢？
上面的线程握住s1这个同步监视器以后，再把s1和s2分别去append一下，再接下来就阻塞了，在其阻塞的0.1秒之内，下面这个线程太有可能执行了，下面的线程一执行，下面的现在握住s2，然后也sleep了，当他们两都醒的时候，上面的线程等着拿s2，下面的线程拿着s2等着s1，这样大家就互相僵持下去，所以就出现了死锁

方式三：Lock锁

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

private ReentrantLock lock = new ReentrantLock();

第二步：再把共享数据的代码放到try中，因为try中代码没有出错，所以最后写上finally

第三步：调用lock()

lock.lock();

这行代码就代表被锁住了，能保证在try过程中，是一个单线程的，当代码执行完，或者出现了异常，那就会执行finally代码

第四步：在finally中解锁

finally {
	lock.unlock();
}

完整代码为：

import java.util.concurrent.locks.ReentrantLock;

class Window1 implements Runnable{
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                lock.lock();
                if (ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized与lock的异同
相同：二者都可以解决线程安全问题
不同：
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

优先使用顺序：
lock→同步代码块（已经进入了方法体，分配了相应的资源）→同步方法（在方法体之外）

练习：
在这里插入图片描述
分析：

是否是多线程问题：是，两个储户线程
是否有共享数据：有，账户（或账户余额）
是否有线程安全问题：有
如何解决线程安全问题：同步机制，三种方式

package lianxi;
class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    public void deposit(double amt){
        if (amt>0){
            balance += amt;

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

            System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);
        }
    }
}

class Customer extends Thread{
    private Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }
    }
}

public class AccountTest {
    public static void main(String[] args) {
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

输出结果如下：出现了线程安全问题
在这里插入图片描述

解决办法：只需加一个synchronized即可

public synchronized void deposit(double amt){

输出结果：
在这里插入图片描述

五、线程的通信

线程的通信实际上就是几个方法的使用
涉及到的三个方法：
wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify()：一旦执行此方法，就会唤醒被wait()的一个线程，如果有多个线程被wait()，就唤醒优先级高的那个
notifyAll()：一旦执行此方法，就会唤醒所有被wait()的线程

说明：

这三个方法必须使用在同步代码块或同步方法中。
这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现异常
这三个方法都是被定义在java.lang.Object类中

例：使用两个线程打印1-100，线程1，线程2交替打印

package lianxi;
class Number implements Runnable{
    private int number=1;

    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify();
                if(number<=100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //使得调用wait()的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }

            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

代码的意思是：一开始线程1进来，因为没有wait()，所以无视notify(),把1打印出来了，然后wait()了。然后线程2进来，线程2一进来，就先notify()，就把线程1唤醒了，虽然把线程1唤醒了，但是此时线程2拿着同步监视器，所以线程1醒了，但是也进不来，因为线程2拿着锁，再接下来线程2输出了2，线程2就wait()了，执行了wait()了，会释放锁，线程1拿到了锁，线程1才能进来。。。。（以此往复）

输出结果如下：
在这里插入图片描述

sleep()和wait()的异同
相同点：一旦执行方法，都可以使得当前线程进入阻塞状态
不同点：
①两者声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
②两者调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或同步方法中
③关于是否释放同步监视器：若两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

例题：
在这里插入图片描述
分析：

是否有多线程问题？是，生产者线程，消费者线程
是否有共享数据？是，店员（或产品）
如何解决线程的安全问题？同步机制，三种方法
是否涉及线程的通信？是

package lianxi;

class Productor extends Thread{
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+"：开始生产产品");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}
class Clerk{
    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if (productCount<20){
            productCount++;
            notify();
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    //消费产品
    public synchronized void consumeProduct() {
        if (productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Customer extends Thread{
    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始消费物品");
        while(true){
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor p1 = new Productor(clerk);
        p1.setName("生产者1");
        Customer c1 = new Customer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }
}

本文地址：https://blog.csdn.net/fjswcjswzy/article/details/107498653

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

before社区电量是什么意思 Before社区电量获得方法

before社区电量是什么意思？怎么获得更多的电量？有的朋友对此可能还不太清楚，今天，小编为大家带来了before社区电量获得方法。感兴趣的朋友快来了解一下吧。... [阅读全文]
Before社区怎么同步快手 Before社区绑定快手教程

before社区怎么同步快手？在before社区中，用户可以绑定自己的快手，对快手账户进行关联，今天，小编为大家带来了before社区绑定快手教程。感兴趣的玩家... [阅读全文]
before社区怎么加入小组 before社区关注小组教程

before社区怎么加入小组？before社区是由快手推出的一个主要面向年轻人的兴趣社交平台，在before社区中有许多的小组，今天，小编为大家带来了befor... [阅读全文]
before社区怎么玩 Before社区玩法分享

before社区怎么玩？快手正式上线了一款青年文化社区产品before社区。产品定位是专为文艺青年打造的互动交友社区。今天，小编为大家带来了详细的介绍，感兴趣的... [阅读全文]
springboot解决跨域请求带cookie的问题

记录一次解决Spring boot加vue的跨域问题大家都知道vue跨域请求Spring boot的时候，后端服... [阅读全文]
RecycleView入门详解（教你全面掌握RecycleView用法）

RecycleView小白入门详解（教你全面掌握其用法）RecycleView概念效果展示RecycleView... [阅读全文]
Android Emoji表情字符列表

https://apps.timwhitlock.info/emoji/tables/unicodeimport... [阅读全文]
动态权限请求框架RxPermissions(几行代码搞定权限)

RxPermissions简单使用描述：随着社会的发展人们也开始重视对隐私的保护，谷歌也在Android6.0（... [阅读全文]
ExoPlayer之Extractor媒体文件解封装使用

ExoPlayer之ExtractorExtractor的作用接口说明Extractor的调用内置的Extrac... [阅读全文]
URL路径@PathVariable出现点号“.“时值遭截断问题

一：问题描述SpringMVC项目中通过下面的ＵＲＬ进行GET请求。当version有多个小数点的时候。如ver... [阅读全文]

网友评论


验证码：

荐 一文搞懂Java多线程

2020年07月22日 | 移动技术网IT编程 | 我要评论

文章目录

一、基本概念：程序、进程、线程

二、线程的创建和使用

方式一：继承于Thread类

方式二：实现Runnable接口

方式三：实现Callable接口

方式四：使用线程池

三、线程的生命周期

四、线程的同步

方式一：同步代码块

方式二：同步方法

线程安全的单例模式之懒汉式

线程的死锁问题

方式三：Lock锁

五、线程的通信

您可能感兴趣的文章:

相关文章:

网友评论

荐一文搞懂Java多线程