线程同步

1.synchronized

下面代码，启动了2个线程，对同一个实例syntest的age变量进行自增操作

package com.ljj.study;

public class SynTest {
    private int age = 0;

    public void add() {
        age++;
    }

    public void remove() {
        age--;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // private Object o = new Object();

    private static class SynAddThread implements Runnable {

        private SynTest synTest;
        private String name;

        public SynAddThread(SynTest synTest, String name) {
            this.synTest = synTest;
            this.name = name;
        }

        public void run() {

            for (int i = 0; i < 10000; i++) {
                synTest.add();

            }
            System.out.println(name + " addThread age " + synTest.getAge());

        }

    }

    public static void main(String[] args) throws InterruptedException {
        SynTest syntest = new SynTest();
        SynAddThread sat = new SynAddThread(syntest, "t0");
        Thread t0 = new Thread(sat);

        SynAddThread sat1 = new SynAddThread(syntest, "t1");
        Thread t1 = new Thread(sat1);
        t0.start();
        t1.start();
    }
}

t1 addThread age 148130
t0 addThread age 156546

多次执行，每一次的结果都不同，而且不符合预期结果。原因和cpu时间片轮转机制，线程工作内存，主内存有关吧，准确原因还不知道。

为了获得预期结果，我想着给add方法加上synchronized修饰符 多次执行 结果如下

t0 addThread age 18741
t1 addThread age 20000

t1的值符合预期，t0值不符合。原因是synchronized方法一旦被某个线程执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，所以t0线程执行了一次 synTest.add()返回后，就释放了该锁，然后t0线程阻塞在那，2个线程重新争夺该锁。

所以可以用一个20000大小的数组描述执行顺序[t0,t0,t1,......],10000个t0和10000个t1往这个数组里填充，每执行一次毫无疑问age值+1，age的最终结果就是20000，由于某个线程比较强势提前执行完就先打印结果了，导致最先打印的值大于10000。

synchronized锁又叫可重入锁，意思是说同一线程外层函数获得锁之后 ，内层函数仍然持有锁，这也就是synchronized修饰的方法的锁被某个线程持有后，其他线程不能访问此对象的所有synchronized修饰的方法的原因。

public class SynTest {
    private int age = 0;

    public synchronized void add(int i) {
        age = age + i;
        System.out.println(Thread.currentThread().getName() + "=========" + age);
        if (age < 100) {
            add(i);
        }

    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private Object o = new Object();

    private static class SynAddThread implements Runnable {

        private SynTest synTest;
        private String name;

        public SynAddThread(SynTest synTest, String name) {
            this.synTest = synTest;
            this.name = name;
        }

        public void run() {

            synTest.add(1);

            System.out.println(name + " addThread age " + synTest.getAge());

        }

    }

    public static void main(String[] args) throws InterruptedException {
        SynTest syntest = new SynTest();
        SynAddThread sat = new SynAddThread(syntest, "t0");
        Thread t0 = new Thread(sat);

        SynAddThread sat1 = new SynAddThread(syntest, "t1");
        Thread t1 = new Thread(sat1);
        t0.start();
        t1.start();
    }
}

打印的结果是只有一个线程在执行0-100的自增，这也就是说这个是可重入锁

看来synchronized方法还是不能完全符合预期，我想着用同步代码块的方法 修改代码如下

package com.ljj.study;

public class SynTest {
    private int age = 0;

    public synchronized void add() {
        age++;
    }

    public void remove() {
        age--;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private Object o = new Object();

    private static class SynAddThread implements Runnable {

        private SynTest synTest;
        private String name;

        public SynAddThread(SynTest synTest, String name) {
            this.synTest = synTest;
            this.name = name;
        }

        public void run() {
            synchronized (synTest.o) {
                for (int i = 0; i < 10000; i++) {
                    synTest.add();
                }
                System.out.println(name + " addThread age " + synTest.getAge());

            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        SynTest syntest = new SynTest();
        SynAddThread sat = new SynAddThread(syntest, "t0");
        Thread t0 = new Thread(sat);

        SynAddThread sat1 = new SynAddThread(syntest, "t1");
        Thread t1 = new Thread(sat1);
        t0.start();
        t1.start();
    }
}

执行结果如下，符合预期。2个线程去争夺synTest.o这个锁，谁争取到就执行后面的代码块

总结：synchronized方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁。不是说某线程获得了该锁，就一直持有直到线程结束。

t0 addThread age 10000
t1 addThread age 20000

2.volatile--轻量级同步

不能确保原子性，能确保可见性。

所谓的确保可见性，就是说每次操作该变量时都会把主存中的该变量刷新到线程内存中。

不能确保原子性就是说，在做原子性操作时，假如主内存中的该值改变了不能及时的应用于此次操作中。比如volatile int a ; a=a+1这个操作会先从主内存中获取最新的值（可见性） 然后自增，然而在自增过程中a值在主内存中改变了，a=a+1不能同步此值（不能确保原子性）

public class VolatileUnsafe {
    
    private static class VolatileVar implements Runnable {

        private volatile int a = 0;
        
        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            a = a+1;
            System.out.println(threadName+":======"+a);
            SleepTools.ms(10);
            a = a+1;
            System.out.println(threadName+":======"+a);
        }
    }
    
    public static void main(String[] args) {

        VolatileVar v = new VolatileVar();

        Thread t1 = new Thread(v);
        Thread t2 = new Thread(v);
        Thread t3 = new Thread(v);
        Thread t4 = new Thread(v);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

上述代码每次执行的结果都是千奇百怪的，所以volatile不能保证线程同步。

但是在只有一个线程写，多个线程读的场景下，volatile就可以使用。

3.Thredlocal

public class UseThreadLocal {
    
    //可以理解为 一个map，类型 Map<Thread,Integer>
    static ThreadLocal<Integer> threadLaocl = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 1;
        }
    };

    /**
     * 运行3个线程
     */
    public void StartThreadArray(){
        Thread[] runs = new Thread[3];
        for(int i=0;i<runs.length;i++){
            runs[i]=new Thread(new TestThread(i));
        }
        for(int i=0;i<runs.length;i++){
            runs[i].start();
        }
    }
    
    /**
     *类说明：测试线程，线程的工作是将ThreadLocal变量的值变化，并写回，看看线程之间是否会互相影响
     */
    public static class TestThread implements Runnable{
        int id;
        public TestThread(int id){
            this.id = id;
        }
        public void run() {
            System.out.println(Thread.currentThread().getName()+":start");
            Integer s = threadLaocl.get();//获得变量的值
            s = s+id;
            threadLaocl.set(s);
            System.out.println(Thread.currentThread().getName()+":"
            +threadLaocl.get());
            //threadLaocl.remove();
        }
    }

    public static void main(String[] args){
        UseThreadLocal test = new UseThreadLocal();
        test.StartThreadArray();
    }
}

Thread-0:start
Thread-2:start
Thread-1:start
Thread-2:3
Thread-1:2
Thread-0:1

ThreadLocal可以理解为 一个map，类型 Map<Thread,Integer>，相当于每个线程都有一个该变量的副本，每个线程都只操作自己的副本，但是假如该变量所占空间很大，会很浪费空间。