java基础：synchronized的实战使用方式

1.synchronized的概述

1. 关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块
2. synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的    内存可见性

2.synchronized实现的三种方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

1. 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
2. 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
3. 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

3.synchronized的作用

1. synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保线程互斥的访问同步代码

普通同步方法（PS：这里引用的是同一对象，Test test = new Test()，在方法上使用了synchronized关键字）

分析：当两个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他synchronized实例方法，但是可以访问非synchronized修饰的方法

private static int num = 0;

public synchronized void count() {
    num++;
}

public static void main(String[] args) {

    Test test = new Test();

    for (int i = 0; i < 1000; i++) {
        new Thread(() -> test.count()).start();
    }

    System.out.println(num);
}

静态同步方法（PS：这里可以实例多个不同的对象，方法上使用 static和synchronized）

分析：由例子可知，线程实例化多个不同的对象，但是访问的方法是静态的，多个线程发生了互斥（即一个线程访问，另一个线程只能等着），因为静态方法是依附于类而不是对象的，当synchronized修饰静态方法时，锁是class对象。

private static int num = 0;

public static synchronized void count() {
    num++;
}

public static void main(String[] args) {

    for (int i = 0; i < 1000; i++) {
        new Thread(() -> new Test().count()).start();
    }

    System.out.println(num);
}

同步方法块（PS:这里引用的是同一对象，Test test = new Test(),在方法体内使用synchronized代码块，可以使用this，或统一声明的实例变量test，或Test.class）

分析：将synchronized作用于一个给定的实例对象test ，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有test 实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了test 作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁，如下代码

private static Test test = new Test();

private static int num = 0;

public void count() {
    synchronized (test) {
        num++;
    }
}

public static void main(String[] args) {

    for (int i = 0; i < 1000; i++) {
        new Thread(() -> test.count()).start();
    }

    System.out.println(num);
}

4.在日常开发中，若需要等待所有子线程执行完成，在执行主线程，代码如下：

private static int num = 0;

public void count() {
    synchronized (this) {
        num++;
    }
}

public static void main(String[] args) {

    Test test = new Test();

    ExecutorService exe = Executors.newFixedThreadPool(1000);

    long startTime = System.currentTimeMillis();


    for (int i = 0; i < 1000; i++) {
        exe.execute(new Thread(() -> test.count()));
    }

    exe.shutdown();

    while (true) {
        if (exe.isTerminated()) break;
    }

    long endTime = System.currentTimeMillis();

    System.out.println(endTime - startTime + "ms");
    System.out.println(num);
}