Java线程安全与数据同步

import java.util.HashMap;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args){
//        TickWindowRunnable.test();
//        Mutex.test();
//        TaskExample.test();
//        ThisMonitor.test();
        DeadLock.test();
    }
}

/*
    4.2 初识synchronized关键字

    synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误，如果一个对象
    对多个线程是可见的，那么对该对想的所有读或者写都将通过同步的方式来进行，具体体现如下：
        1.synchronized关键字提供了一种锁的机制，能够确保共享变量的互斥访问，从而防止
            数据不一致的问题出现。
        2.synchronized关键字包括monitor enter和monitor exit两个jvm指令，它能够保证
            在任何时候任何线程执行到monitor enter成功之前都必须从主内存中获取数据，而不是
            从缓存中，在monitor exit运行成功之后，共享内存被更新后的值必须刷入主内存
        3.synchronized的指令严格遵守java happens-before规则，一个monitor exit指令之
            前必定要有一个monitor enter
 */

/*
    4.2.2 synchronized关键字的用法

        1.同步方法：
        2.同步代码块：
            private final Object MUTEX = new Object();

            public void sync(){
                synchronized(MUTEX){
                    //Do Something...
                }
            }
 */
class TickWindowRunnable implements Runnable{
    private int index = 1;
    private final static int MAX = 500;
    private final static Object MUTEX = new Object();

    @Override
    public void run() {
        synchronized (MUTEX){
            while (index<=MAX){
                System.out.println(Thread.currentThread()+"的号码是："+(index++));
            }
        }
    }

    public static void test() {
        final TickWindowRunnable task = new TickWindowRunnable();

        Thread windowThread1 = new Thread(task,"fir");
        Thread windowThread2 = new Thread(task,"sec");
        Thread windowThread3 = new Thread(task,"thi");
        Thread windowThread4 = new Thread(task,"for");
        Thread windowThread5 = new Thread(task,"fif");

        windowThread1.start();
        windowThread2.start();
        windowThread3.start();
        windowThread4.start();
        windowThread5.start();
    }
}

/*
    4.3.1 线程堆栈分析

    线程获取了与mutex关联的monitor锁
        ——额，一个monitor锁与一个mutex关联着，我这个线程现在进入了你的方法
            所以我获取了关联着你这个mutex对象的monitor锁锁锁！！！

 */
class Mutex{
    //注意下这个问题，我发现这个对象都是静态的
    private final static Object MUTEX = new Object();

    public void accessResource(){
        synchronized (MUTEX){
            try{
                TimeUnit.MINUTES.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void test(){
        final Mutex mutex = new Mutex();
        for (int i = 0; i < 5; i++) {
            new Thread(mutex::accessResource).start();
        }
    }
}

/*
==============================================================================================================================
            对 jstack 打印的日志进行分析：
==============================================================================================================================
"Thread-2" #13 prio=5 os_prio=0 tid=0x000000005696a000 nid=0xe54 waiting for monitor entry [0x000000005812e000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at Mutex.accessResource(Test.java:82)
    - waiting to lock <0x00000000ec195368> (a java.lang.Object)     //这个地方说明这个线程在等待锁的释放
    at Mutex$$Lambda$1/1096979270.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)

"Thread-1" #12 prio=5 os_prio=0 tid=0x0000000056969000 nid=0xc38 waiting on condition [0x000000005825e000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at Mutex.accessResource(Test.java:82)
    - locked <0x00000000ec195368> (a java.lang.Object)              //这个地方说明这个线程已经获得锁了
    at Mutex$$Lambda$1/1096979270.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)
==============================================================================================================================

 */

/*
    4.3.2 JVM指令分析
==============================================================================================================================
            JVM指令分析
==============================================================================================================================

    public void accessResource();
    Code:
       0: getstatic     #2       //获取 MUTEX对象
       3: dup
       4: astore_1
       5: monitorenter           //执行monitor enter JVM指令
       6: getstatic     #3
       9: ldc2_w        #4
      12: invokevirtual #6
      15: goto          23       //跳转到23行
      18: astore_2
      19: aload_2
      20: invokevirtual #8
      23: aload_1                //
      24: monitorexit            //执行monitor exit JVM指令
      25: goto          33
      28: astore_3
      29: aload_1
      30: monitorexit
      31: aload_3
      32: athrow
      33: return
==============================================================================================================================

 */

/*
    Monitorenter JVM指令

        每个对象都与一个monitor相关联，一个monitor的lock锁只能被一个线程在同一时间获得，
        在一个线程尝试获得与对象关联monitor的所有权会发生如下几件事情：
            1.如果monitor的计数器为0，则意味这该monitor的lock还没有被获得，某个线程获得
                之后将立即对计数器加一，从此该线程就是这个monitor的所有者了。
            2.如果一个已经拥有该monitor所有权的线程重入，会导致monitor计数器再次累加。
            3.如果monitor已经被其他线程所拥有，则其他线程尝试获取该monitor的所有权时，
                或被陷入阻塞状态，知道monitor计数器变为0，才能再次尝试获取对monitor
                的所有权。

    Monitorexit JVM指令
        当monitor计数器变为0时，被该monitor阻塞的线程将再次尝试获得对该monitor的所有权。
 */

/*
    4.3.3 使用synchronized需要注意的问题

        1.与monitor关联的对象不能为空
        2.synchronized作用域太大了
        3.不同的monitor企图锁相同的方法
 */
class Task implements Runnable{

    private final Object MUTEX = new Object();

    @Override
    public void run() {
        synchronized (MUTEX){

        }
    }

}

class TaskExample{
    public static void test(){
        /*
            案例解析：
                这个案例中构造了5个Runnable实例，Runnable作为线程逻辑执行单元传递给
                Thread~~~线程之间进行monitor lock的争夺只能发生在与monitor关联的
                同一个引用上！！！所以这个地方，需要new 出一个Task对象，或者将MUTEX
                对象编程静态的，但是那没有意义咯，因为你保护的资源大家都有自己的一份，
                哈哈哈哈哈哈哈
         */
        for (int i = 0; i < 5; i++) {
            new Thread(Task::new).start();
        }
    }
}
/*
        4.多个锁的交叉导致死锁

            案例分析：
                如果write方法和read方法，同时在两个线程中调用，而调用了read方法的线程获
                得了MUTEX_READ对象上的monitor锁，调用write方法的线程获得了MUTEX_WRITE
                对象上的monitor锁，就会发生死锁。

 */
class Mutex2{
    private final Object MUTEX_READ = new Object();
    private final Object MUTEX_WRITE = new Object();

    public void read(){
        synchronized (MUTEX_READ){
            synchronized (MUTEX_WRITE){

            }
        }
    }

    public void write() {
        synchronized (MUTEX_WRITE){
            synchronized (MUTEX_READ){

            }
        }
    }
}

/*
    4.4.1 this monitor
 */
class ThisMonitor{
    public synchronized void Method1(){
        System.out.println(Thread.currentThread().getName()+" enter to method1");
        try{
            TimeUnit.MINUTES.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void Method2(){
        System.out.println(Thread.currentThread().getName()+" enter to method2");
        try{
            TimeUnit.MINUTES.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void test(){
        ThisMonitor thisMonitor = new ThisMonitor();
        new Thread(thisMonitor::Method1,"T1").start();
        new Thread(thisMonitor::Method2,"T2").start();
    }
}

/*
==============================================================================================================
            jstack 打印的日志分析
==============================================================================================================
"T2" #12 prio=5 os_prio=0 tid=0x0000000057971800 nid=0xb50 waiting for monitor entry [0x000000005837f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at ThisMonitor.Method2(Test.java:251)
    - waiting to lock <0x00000000eb3c02b8> (a ThisMonitor)
    at ThisMonitor$$Lambda$2/1831932724.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)

"T1" #11 prio=5 os_prio=0 tid=0x000000005796e800 nid=0x16d8 waiting on condition [0x000000005824e000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at ThisMonitor.Method1(Test.java:245)
    - locked <0x00000000eb3c02b8> (a ThisMonitor)
    at ThisMonitor$$Lambda$1/1096979270.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:748)
==============================================================================================================

    自己的分析：
        1.我看到了T1进行了加锁，T2在等待锁
        2.额，这个类似与什么情况类似？这个类似与我准备了一个MUTEX对象，用它来保护两个语句块
            按照我之前看到的，一点需要进入到这个对象保护的区域了，它都需要需询问一下monitor
            能否给个锁。但是发现不能狗获得这个锁。所以就只有一个方法运行了。
 */

/*
    4.5.1 程序死锁

        1.交叉锁可导致程序出现死锁
        2.内存不足导致的死锁
        3.一问一答的数据交换
        4.数据库锁
        5.文件锁
        6.死循环引起的死锁

    4.5.2 程序死锁举例
 */
class DeadLock{
    private final Object MUTEX_READ = new Object();
    private final Object MUTEX_WRITE = new Object();

    public void read(){
        synchronized (MUTEX_READ){
            synchronized (MUTEX_WRITE){
                System.out.println("read...");
            }
        }
    }

    public void write() {
        synchronized (MUTEX_WRITE){
            synchronized (MUTEX_READ){
                System.out.println("write...");
            }
        }
    }

    public static void test() {
        final DeadLock deadLock = new DeadLock();

        new Thread(()->{
            while(true){
                deadLock.read();
            }
        },"READ-THEAD").start();

        new Thread(()->{
            while(true){
                deadLock.write();
            }
        },"Write-THEAD").start();
    }
}

/*
    HashMap 不具备线程安全的能力，如果想要使用线程安全的map结构请使用
    ConcurrentHashMap或者使用Collection.synchronizeMap来代替
        ——这个还是了解一下吧。。。

    案例分析：
        书中是这么说的：如果多线程同时写操作的情况下，很容易出现死循环引起的死锁，
        程序运行一段时间后，CPU等资源居高不下。
            ——我想知道为什么会这样。。。
 */

class HashMapDeadLock{
    private final HashMap<String,String> map = new HashMap<>();

    public void add(String key, String value) {
        this.map.put(key,value);
    }

    public static void test(){
        final HashMapDeadLock hmdl = new HashMapDeadLock();
        for (int x = 0; x < 2; x++) {
            new Thread(()->{
                for (int i = 1; i < Integer.MAX_VALUE; i++) {
                    hmdl.add(String.valueOf(i),String.valueOf(i));
                }
            }).start();
        }
    }
}

/*
    4.5.3 死锁诊断
        ——这部分没看着，想找本专业的书，看看这部分
 */

——《Java高并发编程详解》笔记