实现线程的暂停、继续、还有解决线程的安全问题

我在学习多线程的途中，想到了一个问题：

有没有什么方法可以随时暂停、继续线程，于是我上网找了一下，可以如下代码实现

package thread;

import java.util.Scanner;

/**
 * @ClassName Test6
 * @Author 瞿肖
 * @Date 2022/7/11 10:36
 */
public class Test6 extends Thread {
    static Object o = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(i);
            try {
                Thread.sleep(250);//休眠0.5秒
                if (i == 5) {
                    System.out.println(Thread.currentThread().getName() + "线程被暂停");
                    pause();
                    System.out.println(Thread.currentThread().getName() + "线程继续");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }

    private void pause() {
        synchronized (o) {
            try {
                o.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        Test6 t1 = new Test6();
        Test6 t2 = new Test6();
        t1.setName("A");
        t2.setName("B");
        t1.start();
        t2.start();
        try {
            Thread.sleep(5000);
            synchronized (o) {
                System.out.println("解开所有暂停的线程");
                o.notifyAll();
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

注意，解开的时候一定要用调用wait()的同一个对象，不能使用另一个Object的对象来调用；

 不然会出现A、B线程一直等待唤醒、程序就一直停在这里不动了

还要注意的一点是：

            synchronized (对象 A) {
               方法体...
            }

同步传入的对象A,在方法体里面只能只用A,若是使用别的会报：

IllegalMonitorStateException异常

所以synchronized 的对象同步使用必须是同一个哦。

还有另外一个方法，利用lock接口的实现类解决：

package thread;

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

/**
 * @ClassName Test7
 * @Author 瞿肖
 * @Date 2022/7/11 14:32
 */


public class Test7 implements Runnable {
    private int sum = 100;
    ReentrantLock rl = new ReentrantLock();

    @Override
    public void run() {

        while (true) {
            rl.lock();
            try {
                if (sum > 0) {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "\t" + sum--);
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {//只要完成了，无论如何都要释放锁
                rl.unlock();
            }

        }
    }

    public static void main(String[] args) {
        Test7 t = new Test7();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();

    }
}

利用它的lock方法进行获取锁，然后执行完毕后再unlock释放锁，

而且要把lock的对象放外面成为成员方法，只有获取到锁的线程才能执行程序，

没获取到的要进行等待。