小知识点记录:同步与锁的基础知识

---

模拟线程同步的案例

说到同步;这个synchronized 关键字就比较熟悉了;

比如下面这段代码,保证了一秒执行一次输出 你好.

public class MyConcurrent01 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            method1();
        }
    }

    //测试方法1;
    private static void method1() {
        new Thread(() -> {
            synchronized (MyConcurrent01.class) {
                try {
                    System.out.println("你好");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

当然也可使用Lock接口的子类ReentrantLock来实现同步效果.

public class MyConcurrent02 {
    static Lock R = new ReentrantLock();

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            method2();
        }
    }

    //测试方法2;
    private static void method2() {
        new Thread(() -> {
            try {
                //手动加锁;
                R.lock();
                System.out.println("你好");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //手动解锁.
                R.unlock();
            }
        }).start();
    }
}

这个ReentrantLock锁比较灵活,可使用tryLock()方法尝试加锁;

public class MyConcurrent02 {
    static Lock R = new ReentrantLock();

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            method2();
        }
    }
    //测试方法2;
    private static void method2() {
        new Thread(() -> {
            boolean flag = false;
            //可以灵活尝试加锁;
            try {
                flag = R.tryLock();
                if (flag) {
                    System.out.println("你好");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //手动解锁.
                if (flag) {
                    R.unlock();
                }
            }
        }).start();
    }
}

运行时发现只有一个线程抢到了资源

---

这个tryLock()方法也有一个重载方法tryLock(long time, TimeUnit unit) 可输入尝试的时间;
若在该时间内没有获取到资源,则停止;

尝试在案例中使用; 当线程在1.5秒内没有获取到资源就停止;

---

让线程主动释放锁的方式

若采用synchronized保持同步时,可使用wait() 方法让当前线程进入等待状态且释放锁;
当然若要唤醒等待状态的线程,可以使用notify() 方法或者notifyAll()方法.

public class MyConcurrent01 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            method1();
        }
        Thread.sleep(1000);
        //唤醒等待中的线程;
        synchronized (MyConcurrent01.class) {
            MyConcurrent01.class.notifyAll();
        }
    }

    //测试方法1;
    private static void method1() {
        new Thread(() -> {
            synchronized (MyConcurrent01.class) {
                try {
                    //线程进入等待状态;
                    MyConcurrent01.class.wait();
                    System.out.println("你好");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

若采用ReentrantLock保持同步时,需要先使用newCondition()方法获取到一个Condition类型的变量,然后调用await()方法来让线程进入同步状态; 可使用signal() 方法 或者 signalAll()方法唤醒等待中的线程.

public class MyConcurrent02 {

    static Lock R = new ReentrantLock();
    //注意这里需要使用 Condition类型的变量来操作同步中的线程;
    static Condition condition = R.newCondition();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            method2();
        }
        Thread.sleep(1000);
        R.lock();
        //唤醒线程;
        condition.signalAll();
        R.unlock();
    }

    //测试方法2;
    private static void method2() {
        new Thread(() -> {
            try {
                //手动加锁;
                R.lock();
                //线程进入等待状态;
                condition.await();
                System.out.println("你好");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //手动解锁.
                R.unlock();
            }
        }).start();
    }
}

---

什么是可重入?

同一个线程对于某个资源进行多次加锁使用时不会产生死锁;

---

线程阻塞

wait 等待阻塞,Object类的方法,对于获取到资源的线程生效,使用该方法的线程会释放锁;线程进入等待状态;

sleep休眠阻塞,Thread类的方法,使用该方法的线程不会释放锁,线程进入休眠状态;

join阻塞; 当前调用该方法的线程,必须等待指定的线程执行后才能执行;

---

线程终止

(1) 使用stop()方法,强制终止线程;
(2)使用destroy()方法,销毁线程;
(3)使用interrupt()方法,中断线程, 注意这里的中断并不是真的中断了线程,只是赋予一个标志;向线程发出一个中断的信号,具体的中断线程还需要在线程内部具体操作中进行判断处理 ,比如使用isInterrupted() 判断是否有中断信号;

boolean interrupted = Thread.currentThread().isInterrupted();

可看到 wait() 方法,sleep() 方法,join()方法的具体实现中都有抛出中断异常的痕迹.

---