欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java - 线程

程序员文章站 2022-05-04 17:11:42
...

线程是程序中的执行线程，Java 虚拟机允许应用程序并发地运行多个执行线程。

每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

创建新执行线程有两种方法：

  • 一种方法是将类声明为 Thread 的子类，该子类应重写 Thread 类的 run() 方法，接下来可以分配并启动该子类的实例。
  • 另一种方法是声明实现 Runnable 接口的类，该类实现 run() 方法，然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main() 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：

  • 调用了 Runtime 类的 exit() 方法，并且安全管理器允许退出操作发生。
  • 非守护线程的所有线程都已停止运行，无论是通过从对 run() 方法的调用中返回，还是通过抛出一个传播到 run() 方法之外的异常。

一、创建线程类

1 创建Thread类的子类

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体中设置线程需要完成的任务，因此把run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程。

start()方法使得该线程开始执行，JVM调用该线程的run()方法，其执行的结果是两个线程并发地运行；当前线程（调用 start() 方法的那个线程）和另一个线程（创建的新线程，会执行其 run() 方法）。多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动。 主线程是指执行主方法（main()方法）的那个线程，注意父线程不一定是主线程。

注：Java程序属于抢占式调度，哪个线程的优先级高哪个线程就优先执行，同一个优先级的线程则随机选择一个执行。

src/main/java/top/onefine/demo/thread/MyThread.java：

package top.onefine.demo.thread;

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("run: " + i);
        }
    }
}

src/main/java/top/onefine/demo/thread/Demo01Thread.java

package top.onefine.demo.thread;

public class Demo01Thread {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();  // mt对象
        myThread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("main: " + i);
        }
    }
}

执行结果（某一种）：

main: 0
main: 1
run: 0
run: 1
run: 2
run: 3
run: 4
main: 2
main: 3
run: 5
main: 4
main: 5
main: 6
main: 7
main: 8
main: 9
run: 6
run: 7
run: 8
run: 9

多线程内存图解

Java - 线程

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

多线程执行时，在栈内存中每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈。
Java - 线程
Java - 线程

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

Thread类

至此已经可以完成最基本的线程开启，在完成操作过程中用到了 java.lang.Thread 类，此类的API中中定义了有关线程的一些方法，具体如下：
构造方法：

  • public Thread() ：分配一个新的线程对象。
  • public Thread(String name) ：分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) ：分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target, String name) ：分配一个带有指定目标新的线程对象并指定名字。

常用方法：

  • public String getName()：获取当前线程名称。可以先获取到当前正在执行的线程，再通过此方法获取当前线程名称。
  • public void setName(String name)：改变线程名称，使之与参数name相同。
  • public void start()：导致此线程开始执行; Java虚拟机调用此线程的run方法。
  • public void run()：此线程要执行的任务在此处定义代码。
  • public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
  • public static Thread currentThread()：返回对当前正在执行的线程对象的引用。
栗子1：获取线程名称

src/main/java/top/onefine/demo/thread/MyThread.java

package top.onefine.demo.thread;

public class MyThread extends Thread {

    @Override
    public void run() {
        String name = super.getName();// 直接获取线程的名称
        System.out.println("线程名称：" + name);
    }
}

src/main/java/top/onefine/demo/thread/Demo01Thread.java

package top.onefine.demo.thread;

public class Demo01Thread {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

        Thread currentThread = Thread.currentThread();
        System.out.println("主线程名称：" + currentThread.getName());  // Thread.currentThread().getName();
        new MyThread().start();
        new MyThread().start();
    }
}

执行结果（不唯一）：

线程名称：Thread-0
主线程名称：main
线程名称：Thread-2
线程名称：Thread-1
栗子2：设置线程名称

src/main/java/top/onefine/demo/thread/MyThread.java：

package top.onefine.demo.thread;

public class MyThread extends Thread {

    public MyThread() {
        super();
    }

    // 创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，
    // 把线程名称传递给父类，让父类（Thread）给子线程起一个名字
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName());
    }
}

src/main/java/top/onefine/demo/thread/Demo01Thread.java：

package top.onefine.demo.thread;

public class Demo01Thread {

    public static void main(String[] args) {
//        MyThread myThread = new MyThread();
//        myThread.setName("Thread-one");
        MyThread myThread = new MyThread("Thread-fine");
        myThread.start();

        System.out.println("主线程名称：" + Thread.currentThread().getName());
        new MyThread().start();
        new MyThread().start();
    }
}
栗子3：sleep()使用

src/main/java/top/onefine/demo/thread/MyThread.java：

package top.onefine.demo.thread;

public class MyThread extends Thread {

    @Override
    public void run() {
        // 模拟秒表
        for (int i = 0; i < 60; i++) {
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i + 1);
        }
    }
}

src/main/java/top/onefine/demo/thread/Demo01Thread.java：

package top.onefine.demo.thread;

public class Demo01Thread {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

2 实现Runnable接口方式（重点）

实现 java.lang.Runnable接口也是非常常见的一种，只需要重写run()方法即可。Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。

步骤如下：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  3. 调用线程对象的start()方法来启动线程。

src/main/java/top/onefine/demo/thread/MyThread.java：

package top.onefine.demo.thread;

public class MyThread implements Runnable {

    // 实现Runnable接口的run()方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

src/main/java/top/onefine/demo/thread/Demo02Runnable.java：

package top.onefine.demo.thread;

public class Demo02Runnable {

    public static void main(String[] args) {
        // 1. 创建Runnable接口的实现类对象
        MyThread run = new MyThread();
        // 2. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread myThread = new Thread(run);
        // 3. 调用Thread类中的start方法，开启新的线程执行run方法
        myThread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性

  • Java中一个类只能继承一个类，类继承了Thread类就不能继承其他的类
  • 实现了Runnable接口，还可以继承其他的类，实现其他的接口

2.增强了程序的扩展性，降低了程序的耦合性(解耦)

  • 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
  • 实现类中，重写了run方法：用来设置线程任务
  • 创建Thread类对象，调用start方法：用来开启新线程

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

3. Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势总结：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

4. 匿名内部类方式实现线程的创建

src/main/java/top/onefine/demo/thread/Demo03InnerClassThread.java：

package top.onefine.demo.thread;

public class Demo03InnerClassThread {

    public static void main(String[] args) {
        // Thread
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }.start();

        // Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }).start();
    }
}

执行结果（不唯一）：

Thread-1: 0
Thread-0: 0
Thread-0: 1
Thread-1: 1
Thread-1: 2
Thread-1: 3
Thread-1: 4
Thread-1: 5
Thread-0: 2
Thread-0: 3
Thread-1: 6
Thread-1: 7
Thread-0: 4
Thread-0: 5
Thread-0: 6
Thread-0: 7
Thread-1: 8
Thread-0: 8
Thread-1: 9
Thread-1: 10
Thread-0: 9
Thread-1: 11
Thread-1: 12
Thread-1: 13
Thread-1: 14
Thread-1: 15
Thread-1: 16
Thread-1: 17
Thread-1: 18
Thread-1: 19
Thread-0: 10
Thread-0: 11
Thread-0: 12
Thread-0: 13
Thread-0: 14
Thread-0: 15
Thread-0: 16
Thread-0: 17
Thread-0: 18
Thread-0: 19

二、线程安全

1. 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

src/main/java/top/onefine/demo/thread/RunnableImpl.java：

package top.onefine.demo.thread;

/**
 * 实现卖票案例
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
        // 让卖票操作重复执行
        while (true) {
            // 先判断票是否存在
            if (ticket > 0) {
                // 让程序睡眠，大概率暴露出安全问题
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                this.ticket--;
            } else break;
        }

    }
}

src/main/java/top/onefine/demo/thread/Demo04ThreadSafe.java：

package top.onefine.demo.thread;

/**
 * 模拟卖票案例
 */
public class Demo04ThreadSafe {

    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();

        Thread thread_1 = new Thread(runnable);
        Thread thread_2 = new Thread(runnable);
        Thread thread_3 = new Thread(runnable);

        thread_1.start();
        thread_2.start();
        thread_3.start();
    }
}

执行结果（不唯一）：

Thread-1正在卖第100张票
Thread-0正在卖第100张票
Thread-2正在卖第100张票
Thread-2正在卖第97张票
Thread-1正在卖第97张票
Thread-0正在卖第97张票
Thread-2正在卖第94张票
Thread-0正在卖第94张票
Thread-1正在卖第94张票
Thread-0正在卖第91张票
Thread-2正在卖第91张票
Thread-1正在卖第91张票
Thread-0正在卖第88张票
Thread-2正在卖第88张票
Thread-1正在卖第88张票
Thread-2正在卖第85张票
Thread-1正在卖第85张票
Thread-0正在卖第85张票
Thread-1正在卖第82张票
Thread-0正在卖第82张票
Thread-2正在卖第82张票
Thread-2正在卖第79张票
Thread-0正在卖第79张票
Thread-1正在卖第79张票
Thread-1正在卖第76张票
Thread-0正在卖第76张票
Thread-2正在卖第76张票
Thread-2正在卖第73张票
Thread-1正在卖第73张票
Thread-0正在卖第73张票
Thread-1正在卖第70张票
Thread-0正在卖第70张票
Thread-2正在卖第70张票
Thread-0正在卖第67张票
Thread-1正在卖第67张票
Thread-2正在卖第67张票
Thread-2正在卖第64张票
Thread-1正在卖第64张票
Thread-0正在卖第64张票
Thread-1正在卖第61张票
Thread-2正在卖第61张票
Thread-0正在卖第61张票
Thread-2正在卖第58张票
Thread-1正在卖第58张票
Thread-0正在卖第58张票
Thread-0正在卖第55张票
Thread-2正在卖第55张票
Thread-1正在卖第55张票
Thread-0正在卖第52张票
Thread-2正在卖第52张票
Thread-1正在卖第52张票
Thread-2正在卖第49张票
Thread-1正在卖第49张票
Thread-0正在卖第49张票
Thread-2正在卖第46张票
Thread-1正在卖第46张票
Thread-0正在卖第46张票
Thread-2正在卖第43张票
Thread-0正在卖第42张票
Thread-1正在卖第42张票
Thread-1正在卖第40张票
Thread-2正在卖第40张票
Thread-0正在卖第40张票
Thread-0正在卖第37张票
Thread-1正在卖第36张票
Thread-2正在卖第37张票
Thread-1正在卖第34张票
Thread-0正在卖第34张票
Thread-2正在卖第32张票
Thread-1正在卖第31张票
Thread-0正在卖第31张票
Thread-2正在卖第29张票
Thread-0正在卖第28张票
Thread-1正在卖第28张票
Thread-2正在卖第26张票
Thread-0正在卖第25张票
Thread-1正在卖第25张票
Thread-2正在卖第23张票
Thread-0正在卖第22张票
Thread-1正在卖第22张票
Thread-2正在卖第20张票
Thread-0正在卖第19张票
Thread-1正在卖第19张票
Thread-2正在卖第17张票
Thread-1正在卖第16张票
Thread-0正在卖第16张票
Thread-2正在卖第14张票
Thread-1正在卖第13张票
Thread-0正在卖第13张票
Thread-2正在卖第11张票
Thread-0正在卖第10张票
Thread-1正在卖第10张票
Thread-2正在卖第8张票
Thread-1正在卖第7张票
Thread-0正在卖第7张票
Thread-2正在卖第5张票
Thread-1正在卖第4张票
Thread-0正在卖第4张票
Thread-2正在卖第2张票
Thread-0正在卖第1张票
Thread-1正在卖第1张票
Thread-2正在卖第-1张票

发现程序出现了两个问题：

  1. 相同的票数，比如1这张票被卖了两回。
  2. 不存在的票，比如-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题是不能产生的，可以让一个线程在访问共享数据的时候，无论是否失去了cpu的执行权（控制权），让其他的线程只能等待，等待当前程序卖完票，其他线程再进行卖票。保证只有一个线程在卖票。

线程安全问题都是由**全局变量（如类中定义int i = 9）及静态变量（如static int j = 8;）**引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

2. 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题，也就是解决重复票与不存在票问题，就要保证每个线程都能正常执行原子操作，Java中提供了同步机制(synchronized)来解决。

有三种方式完成同步操作：

  1. 同步代码块

  2. 同步方法

  3. 锁机制

2.1 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

同步锁（对象锁或对象监视器）：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。锁的作用是把同步代码块锁住，只让一个线程在同步代码块中执行。

  1. 锁对象 可以是任意类型。
  2. 多个线程对象 要使用同一把锁。

src/main/java/top/onefine/demo/thread/RunnableImpl.java：

package top.onefine.demo.thread;

/**
 * 使用同步代码块解决线程安全问题
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 创建一个锁对象
    Object obj = new Object();

    // 设置线程任务：卖票
    @Override
    public void run() {
        // 让卖票操作重复执行
        while (true) {
            // 同步代码块
            synchronized (obj) {
                // 先判断票是否存在
                if (ticket > 0) {
                    // 让程序睡眠，大概率暴露出安全问题
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    this.ticket--;
                } else break;
            }
        }
    }
}

线程遇到synchronized代码块时会检查synchronized代码块是否有锁对象，若有就会获取到锁对象，进入到同步中执行。执行完同步代码块中的代码，线程就会把锁对象归还。若没有就会进入到阻塞状态，一直等待其他线程归还锁对象。即同步中的线程没有执行完不会释放锁，同步外的线程没有锁进不去同步。

同步保证了只能有一个线程在同步中执行共享数据，保证了安全，但程序频繁的判断锁，获取锁，释放锁，会造成程序的效率低下。

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

2.2 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。同步方法把方法内部的代码锁住。

同步方法的锁对象——同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

package top.onefine.demo.thread;

/**
 * 使用同步代码方法解决线程安全问题
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private int ticket = 100;

    // 创建一个锁对象
    Object obj = new Object();

    // 把访问了共享数据的代码抽取出来，放到一个方法中
    // 设置线程任务：卖票
    @Override
    public void run() {
    	// 可以优化，比如先判断是否大于0
        // 让卖票操作重复执行
        do {
            payTicket();
        } while (ticket > 0);
    }

    // 定义一个同步方法
    public synchronized void payTicket() {
        // 先判断票是否存在
        if (ticket > 0) {
            // 让程序睡眠，大概率暴露出安全问题
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
            this.ticket--;
        }
    }

    /* 
    public void payTicket() {
        // 先判断票是否存在
        synchronized (this) {
            if (ticket > 0) {
                // 让程序睡眠，大概率暴露出安全问题
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                this.ticket--;
            }
        }
    }
    */
}

静态方法：

package top.onefine.demo.thread;

/**
 * 使用同步代码方法解决线程安全问题
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private static int ticket = 100;

    // 把访问了共享数据的代码抽取出来，放到一个方法中
    // 设置线程任务：卖票
    @Override
    public void run() {
        // 可以优化，比如先判断是否大于0
        if (!(ticket > 0))
            return;
        // 让卖票操作重复执行
        do {
            payTicketStatic();
        } while (ticket > 0);
    }

    // 定义一个静态同步方法
    public static synchronized void payTicketStatic() {
        // 先判断票是否存在
        if (ticket > 0) {
            // 让程序睡眠，大概率暴露出安全问题
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
            ticket--;
        }
    }
}

this是创建对象之后产生的，静态方法优先于对象，所以静态方法的锁对象是本类的class属性，即class文件对象（反射）：

package top.onefine.demo.thread;

/**
 * 使用同步代码方法解决线程安全问题
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private static int ticket = 100;

    // 把访问了共享数据的代码抽取出来，放到一个方法中
    // 设置线程任务：卖票
    @Override
    public void run() {
        // 可以优化，比如先判断是否大于0
        if (!(ticket > 0))
            return;
        // 让卖票操作重复执行
        do {
            payTicketStatic();
        } while (ticket > 0);
    }

    // 定义一个同步方法
    public static void payTicketStatic() {
        // 先判断票是否存在
        synchronized (RunnableImpl.class) {
            if (ticket > 0) {
                // 让程序睡眠，大概率暴露出安全问题
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

2.3 锁机制-Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

  • public void lock() :加同步锁。
  • public void unlock() :释放同步锁。

java.util.concurrent.locks.ReentrantLock类实现了Lock接口

package top.onefine.demo.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用Lock锁解决线程安全问题
 */
public class RunnableImpl implements Runnable {
    // 定义一个多线程共享的票源
    private int ticket = 100;

    Lock lock = new ReentrantLock();

    // 把访问了共享数据的代码抽取出来，放到一个方法中
    // 设置线程任务：卖票
    @Override
    public void run() {
        // 可以优化，比如先判断是否大于0
        if (!(ticket > 0))
            return;
        // 让卖票操作重复执行
        do {
            // 先判断票是否存在
            lock.lock();
            if (ticket > 0) {
                // 让程序睡眠，大概率暴露出安全问题
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();  // 无论程序是否异常，都释放锁
                }
            }

        } while (ticket > 0);
    }
}

三、线程状态

相关标签： # Java

上一篇： php为png/jpg/gif格式图片添加水印

下一篇： js控制时间每秒自己运动

推荐阅读