【并发编程】1 synchronized底层实现原理、Java内存模型JMM；monitor、CAS、乐观锁和悲观锁；对象的内存结构、Mark Word、锁升级

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.2</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.2</version>
</dependency>

public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 案例演示: 一个线程对共享变量的修改,另一个线程不能立即得到最新值
 */
public class Test01Visibility {
    private final static Logger LOG = LoggerFactory.getLogger(Test01Visibility.class);
    // 多个线程都会访问的数据，我们称为线程的共享数据
    //1.创建一个共享变量
    private static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        //2.创建一个线程不断读取共享变量
        new Thread(() -> {
            while(run) {
            }
            LOG.info("{} 读取run：{}，线程结束", Thread.currentThread().getName(), run);
//            System.out.println(Thread.currentThread().getName() + " 读取run：" + run + "，线程结束");
        }, "Thread1").start();

        Thread.sleep(1000);

        //3.创建一个线程修改共享变量
        new Thread(() -> {
            run = false;
            LOG.info( "{} 修改run值为：{}", Thread.currentThread().getName(), run);
//            System.out.println(Thread.currentThread().getName() + " 修改run值为：" + run);
        }, "Thread2").start();

    }

}

/**
 * 目标：演示原子性问题
 * 1.定义一个共享变量number
 * 2.对number进行1000的++操作
 * 3.使用5个线程来进行
 */
public class Test02Atomicity {
    //1.定义一个共享变量number
    private static int number = 0;

    public static void main(String[] args) throws InterruptedException {
        //2.对number进行1000的++操作
        Runnable increment = () -> {
            for (int i = 0; i < 1000; i++) {
                number++;
            }
        };

        List<Thread> list = new ArrayList<>();
        //3.使用5个线程来进行
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(increment);
            t.start();
            list.add(t);
        }

        for (Thread thread : list) {
            //让主线程等待自己创建的线程执行完毕，5个线程执行完 再取number的值
            thread.join();
        }

        System.out.println("number=" + number);  //值有多种可能，2677、4202、4722、4910、5000


    }
}

9: getstatic     #18                 // Field number:I
12: iconst_1
13: iadd
14: putstatic     #18                 // Field number:I

<dependency>
    <groupId>org.openjdk.jcstress</groupId>
    <artifactId>jcstress-core</artifactId>
    <version>0.14</version>
</dependency>

import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;

@JCStressTest     //用并发压缩工具jcstress 测试类方法
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")    //@Outcome 对输出结果进行处理， 1 4 打印ok，0 打印danger
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger")
@State
public class TestOrdering {
    int num = 0;
    boolean ready = false;

    //线程1执行的代码
    @Actor   //@Actor 表示有多个线程来操作这两个方法
    public void actor1(I_Result r) {
        if (ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

    //线程2执行的代码  对两个变量进行修改
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

@Actor
public void actor2(I_Result r) {
    ready = true;
    num = 2;
}

<dependencies>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.2</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.2</version>
    </dependency>

    <dependency>
        <groupId>org.openjdk.jcstress</groupId>
        <artifactId>jcstress-core</artifactId>
        <version>0.14</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <!-- jar生成路径 -->
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.2</version>
            <executions>
                <execution>
                    <id>main</id>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <!-- 打包的名字 jcstress.jar -->
                        <finalName>jcstress</finalName>
                        <!-- 调用下面两个类 -->
                        <transformers>
                            <transformer
                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>org.openjdk.jcstress.Main</mainClass>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/TestList</resource>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>

    </plugins>
</build>

synchronized (锁对象) {
	// 受保护资源;
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 案例演示: 一个线程对共享变量的修改,另一个线程不能立即得到最新值
 */
public class Test01Visibility {
    private final static Logger LOG = LoggerFactory.getLogger(Test01Visibility.class);
    //1.创建一个共享变量，
    //加volatile：当修改的值同步回主内存，有个缓存一致性协议，会把其他工作内存的值全部设置为失效，线程会重新读取共享内存的值
    private static volatile boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        //2.创建一个线程不断读取共享变量
        new Thread(() -> {
            while(run) {
            }
            LOG.info("{} 读取run：{}，线程结束", Thread.currentThread().getName(), run);
        }, "Thread1").start();

        Thread.sleep(1000);

        //3.创建一个线程修改共享变量
        new Thread(() -> {
            run = false;
            LOG.info( "{} 修改run值为：{}", Thread.currentThread().getName(), run);
        }, "Thread2").start();

    }

}

public class Test01Visibility {
    private final static Logger LOG = LoggerFactory.getLogger(Test01Visibility.class);

    private static boolean run = true;
    private static Object obj = new Object();
    public static void main(String[] args) {
        //2.创建一个线程不断读取共享变量
        new Thread(() -> {
            while(run) {
                synchronized (obj ) {
                }
            }
            LOG.info("{} 读取run：{}，线程结束", Thread.currentThread().getName(), run);
        }, "Thread1").start();

        //3.创建一个线程修改共享变量
        new Thread(() -> {
            run = false;
            LOG.info( "{} 修改run值为：{}", Thread.currentThread().getName(), run);
        }, "Thread2").start();
    }

}

public class Test02Atomicity {
    //1.定义一个共享变量number
    private static int number = 0;
    private static Object obj = new Object();
    public static void main(String[] args) throws InterruptedException {
        //2.对number进行1000的++操作
        Runnable increment = () -> {
            for (int i = 0; i < 1000; i++) {
                //需要锁对象，故创建一把锁
                synchronized (obj) {  //obj为锁对象，也可使用synchronized (Test02Atomicity.class)
                    number++; //synchronized保证 number++ 为原子操作。线程获取不到锁 就会等待
                }
            }
        };

        List<Thread> list = new ArrayList<>();
        //3.使用5个线程来进行
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(increment);
            t.start();
            list.add(t);
        }

        for (Thread thread : list) {
            //让主线程等待自己创建的线程执行完毕
            thread.join();
        }

        System.out.println("number=" + number);  //5000

    }
}

//写后读
int a = 1; 
int b = a;

//写后写
int a = 1;
int a = 2;

//读后写   如果重排序将 b=a放到最后，b的值可能会不同，1、2
int a = 1;
int b = a;
int a = 2;

int a = 1;
int b = 2;
int c = a + b;

//可以这样
int a = 1;
int b = 2;
int c = a + b;

//也可重排序为如此，两种方式操作的结果相同
int b = 2;
int a = 1;
int c = a + b;

@JCStressTest     //用并发压缩工具jcstress 测试类方法
@Outcome(id = {"1"}, expect = Expect.ACCEPTABLE, desc = "ok")  
@Outcome(id = {"4"}, expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger1")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger")
@State
public class TestOrdering {
    volatile int num = 0;
    volatile boolean ready = false;

    @Actor   //@Actor 表示有多个线程来操作这两个方法
    public void actor1(I_Result r) {
        if (ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

@JCStressTest     //用并发压缩工具jcstress 测试类方法
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")    //@Outcome 对输出结果进行处理， 1 4 打印ok
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger")
@State
public class TestOrdering {
    private static Object obj = new Object();
    int num = 0;
    boolean ready = false;

    //线程1执行的代码
    @Actor   //@Actor 表示有多个线程来操作这两个方法
    public void actor1(I_Result r) {
        synchronized (obj) {
            if (ready) {
                r.r1 = num + num;
            } else {
                r.r1 = 1;
            }
        }
    }

    //线程2执行的代码  对两个变量进行修改
    @Actor
    public void actor2(I_Result r) {
        synchronized (obj) {
            num = 2;
            ready = true;
        }
    }
}

@JCStressTest     
@Outcome(id = {"1"}, expect = Expect.ACCEPTABLE, desc = "ok")  
@Outcome(id = {"4"}, expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger1")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger")
@State
public class TestOrdering {
    //...
}

/*
目标：演示synchronized可重入
    1.自定义一个线程类
    2.在线程类的run方法中使用嵌套的同步代码块
    3.使用两个线程来执行
 */
public class Demo01 {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
    }
}


//1.自定义一个线程类
class MyThread extends Thread {
    @Override
    public void run() {
        synchronized (MyThread.class) {
            System.out.println(getName() + "进入了同步代码块1");

            synchronized (MyThread.class) {
                System.out.println(getName() + "进入了同步代码块2");
            }

        }
    }
}

//同一个类的两个不同方法
public class Demo01 {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        synchronized (MyThread.class) {
            System.out.println(getName() + "进入了同步代码块1");

            //锁重入跟调用哪个对象、哪个方法无关，主要看哪个线程、哪个锁
            test01();
        }
    }

    //方式二 放同一个类的其他方法中
    public void test01() {
        synchronized (MyThread.class) {
            System.out.println(getName() + "进入了同步代码块2");
        }
    }
}

//其他类的方法
public class Demo01 {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
    }

    //方式三 放其他类的方法中
    public static void test01() {
        synchronized (MyThread.class) {
            String name = Thread.currentThread().getName();
            System.out.println(name + "进入了同步代码块2");
        }
    }
}


class MyThread extends Thread {
    @Override
    public void run() {
        synchronized (MyThread.class) {
            System.out.println(getName() + "进入了同步代码块1");

            //锁重入跟调用哪个对象、哪个方法无关，主要看哪个线程、哪个锁
            Demo01.test01();

        }
    }
}

/*
    目标:演示synchronized不可中断
        1.定义一个Runnable
        2.在Runnable定义同步代码块
        3.先开启一个线程来执行同步代码块,保证不退出同步代码块
        4.后开启一个线程来执行同步代码块(阻塞状态)
        5.停止第二个线程
 */
public class Demo02_Uninterruptible {
    private static Object obj = new Object();
    public static void main(String[] args) throws InterruptedException {
        //1.定义一个Runnable
        Runnable run = () -> {
            //2.在Runnable定义同步代码块
            synchronized (obj) {
                String name = Thread.currentThread().getName();
                System.out.println(name + "进入同步代码块");
                //保证不退出代码块
                try {
                    Thread.sleep(888888);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //3.先开启一个线程来执行同步代码块,保证不退出同步代码块
        Thread t1 = new Thread(run);
        t1.start();
        Thread.sleep(1000);
        //4.后开启一个线程来执行同步代码块(阻塞状态)
        Thread t2 = new Thread(run);
        t2.start();   //t2处于阻塞状态

        //5.停止第二个线程
        System.out.println("停止线程前");
        t2.interrupt();
        System.out.println("停止线程后");

        System.out.println(t1.getState());
        System.out.println(t2.getState());
    }

}

/*
    目标：演示Lock不可中断和可中断
 */
public class Demo03_Interruptible {
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
//        test01();
        test02();
    }

    //演示Lock不可中断 lock()方法
    public static void test01() throws InterruptedException {
        Runnable run = () -> {
            String name = Thread.currentThread().getName();
            try {
                lock.lock();   //该方式不可被中断，lock()方法无返回值
                System.out.println(name + "获得锁，进入锁执行");
                Thread.sleep(88888);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();  //释放锁，如果不释放其他线程就获取不到锁
                System.out.println(name + "释放锁");
            }
        };

        Thread t1 = new Thread(run);
        t1.start();
        Thread.sleep(1000);
        Thread t2 = new Thread(run);
        t2.start();

        System.out.println("停止t2线程前");
        t2.interrupt();
        System.out.println("停止t2线程后");
        Thread.sleep(1000);
        System.out.println(t1.getState());
        System.out.println(t2.getState());
    }


//Thread-0获得锁,进入锁执行；Thread-1在指定时间没有得到锁，做其他操作
    //演示Lock可中断
    public static void test02() throws InterruptedException {
        Runnable run = () -> {
            String name = Thread.currentThread().getName();
            boolean b = false;
            try {
                //tryLock在指定时间内 会尝试能否得到锁，能得到 返回true，不能得到 返回false
                b = lock.tryLock(3, TimeUnit.SECONDS);
                if (b) {
                    System.out.println(name + "获得锁,进入锁执行");
                    Thread.sleep(88888);
                } else {
                    System.out.println(name + "在指定时间没有得到锁，做其他操作");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (b) {
                    lock.unlock();
                    System.out.println(name + "释放锁");
                }
            }

        };
        Thread t1 = new Thread(run);
        t1.start();
        Thread.sleep(1000);
        Thread t2 = new Thread(run);
        t2.start();

        // System.out.println("停止t2线程前");
        // t2.interrupt();
        // System.out.println("停止t2线程后");
        //
        // Thread.sleep(1000);
        // System.out.println(t1.getState());
        // System.out.println(t2.getState());
    }
}