synchronize的理解1

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态。

线程安全概念：当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

synchronize是一个关键字。

作用/为什么要使用synchronize：

1. synchronize用来处理多线程环境下， 线程同步的问题，保证数据的准确性 。
2. 有效的解决了共享变量的可见性问题
3. 解决了指令重排序的问题

用synchronize关键字来修饰一个方法、一个代码块的时候，有多个线程并发访问时，能保证同一个时刻只能有一个线程可以执行。

例子：

public class MyThread extends Thread{

    private  int count=5;
    @SneakyThrows
    @Override
    public void run() {
        count--;
        String thName = Thread.currentThread().getName();
        System.out.println("线程"+thName+" count="+count);
    }
    public static void main(String[] args) {
        MyThread myThread=new MyThread();

        Thread threadA = new Thread(myThread,"A");
        Thread threadB = new Thread(myThread,"B");
        Thread threadC = new Thread(myThread,"C");
        Thread threadD = new Thread(myThread,"D");
        Thread threadE = new Thread(myThread,"E");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
        threadE.start();

       while (threadA.isAlive()|| threadB.isAlive()|| threadC.isAlive()
               || threadD.isAlive()|| threadE.isAlive()){

        }
        System.out.println("main finish");
    }

}

结果：

多个线程并发访问同一run方法，打印count结果不是递减，是乱的，没有count=2的时候，行为错误，线程是不安全的，可以给run方法添加锁

如下：

public class MyThread extends Thread{

    private  int count=5;
    @SneakyThrows
    @Override
    public void run() {
        synchronized (this) {
            /**
             * 分析：当多个线程访问MyThread的run方法时，以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的，不是按照代码start()顺序定的），
             * 一个线程想要执行synchronized修饰的方法里的代码：
             * 1 尝试获得锁 
             * 2 如果拿到锁，执行synchronized代码体内容；
             *   拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，
             * 而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）
             */
            count--;
            String thName = Thread.currentThread().getName();
            System.out.println("线程" + thName + " count=" + count);
        }

    }
    public static void main(String[] args) {
        MyThread myThread=new MyThread();

        Thread threadA = new Thread(myThread,"A");
        Thread threadB = new Thread(myThread,"B");
        Thread threadC = new Thread(myThread,"C");
        Thread threadD = new Thread(myThread,"D");
        Thread threadE = new Thread(myThread,"E");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
        threadE.start();

       while (threadA.isAlive()|| threadB.isAlive()|| threadC.isAlive()
               || threadD.isAlive()|| threadE.isAlive()){

        }
        System.out.println("main finish");
    }

}

结果：

count依次递减，行为正确。

tA~tE的执行顺序

不是根据代码的书写顺序决定，而是根据CPU的选择顺序决定