线程同步的方法有哪几种

一：什么是线程同步

线程同步是指两个或多个线程协同步调，按预期的顺序执行代码。
1：若两个或多个线程同时访问同一个共享资源时，需要让多个线程之间按照顺序访问。
2：若线程A的执行依赖线程B的结果，需要依赖线程同步来保证两个线程的执行的顺序。

二：实现线程同步的几种方式

（一）：synchronized

1：synchronized作用有三：

（1）：保证程序执行的原子性

在多线程环境下，线程是CPU调度的基本单位，CPU根据不同的调度算法进行线程换。当一个线程获得时间片后开始执行，在时间片耗尽之后，就会失去CPU使用权。因此，在多线程场景下，由于时间片切换的原因，原子性问题可能会出现。

例如，线程1获得时间片开始执行，但在执行过程中，CPU时间片耗尽，线程1需要让出CPU。这时线程2获得了时间片开始执行。然而，对于线程1而言，它的操作可能并没有完全执行完成，也没有完全不执行，这就是原子性问题的产生。因此，保证原子性是非常重要的。

synchronized是如何保证程序执行的原子性呢？

public class SynchronizedDemo {
    public void methodA(){
        synchronized (this){
            System.out.println("synchronized  -----");
        }
    }
}

通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 javac SynchronizedDemo.java 命令生成编译后的 .class 文件，然后执行javap -c -s -v -l SynchronizedDemo.class。

从图中可以看出：

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置， monitorexit 指令则指明同步代码块的结束位置。

在执行monitorenter时，会尝试获取对象的锁，如果锁的计数器为 0 则表示锁可以被获取，获取后将锁计数器设为 1 也就是加 1。

在执行 monitorexit 指令后，将锁计数器设为 0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

在锁未释放之前，其他线程无法再次获取锁，因此通过monitorenter和monitorexit指令可以保证被synchronized修饰的代码在同一时间只能被一个线程访问，其他线程在锁未释放之前无法访问该代码块。这样，synchronized可以保证方法和代码块内的操作是原子性的。

当线程执行monitorenter指令时，会对Monitor进行加锁，其他线程无法获取锁，除非线程主动解锁。即使在执行过程中，例如CPU时间片用完，线程放弃了CPU，但是并没有进行解锁。由于synchronized的锁是可重入的，线程在下一个时间片中仍然能够获取到锁，并继续执行代码，直到所有代码执行完毕。这样就保证了原子性。

（2）：保证可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值。

在Java内存模型中，所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中使用到的变量的主内存副本拷贝。线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。

不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递需要通过主内存进行数据同步。因此，就可能出现一个线程修改了某个变量的值，但是其他线程无法立即看到修改的值的情况。

为了保证可见性，使用synchronized关键字修饰的代码会在开始执行时加锁，在执行完成后解锁。根据可见性的规则，对一个变量解锁之前，必须先把此变量的值同步回主内存中。这样解锁后，后续的线程就可以访问到被修改后的值。因此，通过synchronized关键字锁住的对象，其值具有可见性。

（3）：保证有序性

有性问题可以理解为在多线程环境下，一个线程中的操作可能会被重排或者乱序执行，而在另一个线程中观察这些操作的顺序可能是无法确定的。

Java允许编译器和处理器对指令进行重排，但是指令重排并不会影响单线程的顺序，它影响的是多线程并发执行的顺序性。synchronized保证了每个时刻都只有一个线程访问同步代码块，也就确定了线程执行同步代码块是分先后顺序的，保证了有序性。

2：synchronized作为java的关键字，可以作用在代码块、实例方法、静态方法、和类。

（1）：修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁

    synchronized void  methodA(){
        System.out.println("synchronized  method-----");
    }

synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的确实是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法。JVM 通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

（2）：修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，进入同步代码前要获得当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份）。所以，如果一个线程 A 调用一个实例对象的非静态 `synchronized` 方法，而线程 B 需要调用这个实例对象所属类的静态 `synchronized` 方法，是允许的，不会发生互斥现象，因为访问静态 `synchronized` 方法占用的锁是当前类的锁，而访问非静态 `synchronized` 方法占用的锁是当前实例对象锁。

synchronized  static void methodB(){
        System.out.println("synchronized static   -----");
    }

（3）：修饰代码块

指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得 当前 class 的锁

public void methodC(){
        synchronized (this){
            System.out.println("synchronized  -----");
        }
    }

（二）：ReentrantLock

ReentranLock是一个支持重入的独占锁，在JUC(java.util.concurrent)包中，底层就是基于AQS实现的。

ReentranLock类本身并没有直接继承AQS（AbstractQueuedSynchronizer），而是创建了一个内部类Sync来继承了AQS,而ReentrantLock类本身的那些方法都是调用Sync里面的方法来实现，而Sync本身自己也是一个抽象类，它还有两个子类，分别是NonfairSync和FairSync，对锁各种实际的实现其实在这两个类中实现，顾名思义，这两个类分别实现了非公平锁和公平锁，在创建ReentrantLock时可以进行选择。

    /**
     *默认创建一个公平锁
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * 根据参数创建一个公平锁或者非公平锁
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

1：lock()

   //会调用Sync类中的lock()方法，所以需要看创建的是公平锁还是非公平锁
   public void lock() {
        sync.lock();
    }

当定义为非公平锁时，先试用CAS的方式更新AQS中的state的状态，默认是0代表没有被获取，当前线程就可以获取锁，然后把state改为1，接着把当前线程标记为持有锁的线程，如果if中的操作失败就表示锁已经被持有了，就会调用acquire()方法

 final void lock() {
            /**
            使用CAS更细state的值，默认是0代表没有被获取，当前线程就可以获取锁，然后把state改为        
            1，接着把当前线程标记为持有锁的线程
            */
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
            //如果if中的操作失败就表示锁已经被持有了，就会调用acquire()方法
                acquire(1);
 }

    /**
    acquire(1)方法会调用abs的方法，这里面调用子类实现的tryAcquire()方法，最终是调用到Sync类中的                
    nonfairTryAcquire()方法，可以看到先判断state是不是0，也就是能不能获取锁，如果不能则判断请求 
    锁的线程和持有锁的是不是同一个，如果是的话就把state的值加1，也就是实现了重入锁
    */
protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
}

当定义为公平锁，在子类FairSync中重写了tryAcquire方法，注意if(c==0)判断中的代码，也就是线程抢夺锁的时候会调用hasQueuedPredecessors()方法，这个方法会判断队列中有没有已经先等待的线程了，如果有则当前线程不会抢到锁，这就实现了公平性，上面nonfairTryAcquire()方法则没有这种判断，所以后来的线程可能会比先等待的线程先拿到锁。

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //判断是否存在等待队列
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

2：tryLock()

可以看到tryLock实际上是非公平锁的实现，不能保证正在排队的线程能拿到锁，因为可能被新来的线程抢走。

 public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

3：unlock()

这个方法是释放锁，最终会调用到Sync类中的tryRelease()方法。在这个方法里面会对state减1，如果减1之后为0就表示当前线程持有次数彻底清空了，需要释放锁。

 public void unlock() {
        sync.release(1);
 }
 public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
 }
 protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
 }

（三）：CountDownLatch

CountDownLatch中count down是倒数的意思，latch则是门闩的含义。整体含义可以理解为倒数的门栓，似乎有一点“三二一，芝麻开门”的感觉。

CountDownLatch的作用也是如此，在构造CountDownLatch(int count)：的时候需要传入一个整数count，在这个整数“倒数”到0之前，主线程需要等待在门口，而这个“倒数”过程则是由各个执行线程驱动的，每个线程执行完一个任务“倒数”一次。

总结来说，CountDownLatch的作用就是等待其他的线程都执行完任务，必要时可以对各个任务的执行结果进行汇总，然后主线程才继续往下执行。

1:CountDownLatch(int count)：构造方法，创建一个新的 CountDownLatch 实例，用给定的计数初始化。参数 count 表示线程需要等待的任务数量。

2:void await()：使当前线程等待，直到计数器值变为0，除非线程被 interrupted。如果计数器的值已经为0，则此方法立即返回。在实际应用中，通常在主线程中调用此方法，等待其他子线程完成任务。

3:boolean await(long timeout, TimeUnit unit)：使当前线程等待，直到计数器值变为0，或者指定的等待时间已到，或者线程被 interrupted。如果计数器的值已经为0，则此方法立即返回。
                        参数 timeout 是指定的等待时间，
                        参数 unit 是 timeout 的单位（如秒、毫秒等）。
                        此方法返回一个布尔值，表示在等待时间内计数器是否变为0。

4:void countDown()：递减计数器的值。如果计数器的结果为0，则释放所有等待的线程。在实际应用中，通常在线程完成任务后调用此方法。

5:long getCount()：获取当前计数的值。返回当前 CountDownLatch 实例内部的计数值。

6:利用CountDownLatch实现ABC的的顺序打印

public class CountDownLatchB {

    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatchA = new CountDownLatch(1);
        CountDownLatch countDownLatchB = new CountDownLatch(1);
        CountDownLatch countDownLatchC = new CountDownLatch(1);

        Thread threadA =  new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchA.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A");
                countDownLatchB.countDown();
            }
        });

        Thread threadB =  new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchB.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("B");
                countDownLatchC.countDown();
            }
        });


        Thread threadC =  new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchC.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("C");
            }
        });

        threadA.start();
        threadB.start();
        threadC.start();
        countDownLatchA.countDown();

    }



}