java中synchronized介绍和用法

synchronized的作用

一句话说出synchronized的作用:  能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全效果。

大概意思: 当多个线程同时访问synchronized修饰的方法或者代码块的时候，要拿到这部分代码的锁才能访问，某一个线程拿到这个锁正在访问的时候，这部分代码是锁住的，其它线程会处于阻塞的状态，只能这个线程释放掉锁之后，其它的多个线程才会去竞争这个锁，拿到之后才能访问。

 synchronized的地位

• synchronized是java的关键字
• 是最基本的互斥同步手段
• 是并发编程元老级角色，并发编程必懂知识 

看看使用并发手段会有什么后果？（两个线程同时执行a++）

public class ThreadDemo3 implements Runnable{

    static int a = 0;
    /**
     * 1.重写run方法，在里面循环10W次，执行a++
     * 2.用两个线程执行，预期的结果输出结果 a=200000
     *
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo3 threadDemo3 = new ThreadDemo3();
        Thread t1 = new Thread(threadDemo3);
        Thread t2 = new Thread(threadDemo3);
        t1.start();
        t2.start();

        // 调用join方法，会让主线程处于等待状态，等到t1,t2线程执行完成以后才去执行
        t1.join();
        t2.join();

        System.out.println(threadDemo3.a);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            a++;
        }
    }
}

下面是我多次运行的结果，发现每次运行的结果必会比预期运行的少

这个是为什么那？？？

以为a++，看上去是一个操作，实际上包含了三个操作:

1.  读取a
2. 将a + 1
3. 将a的值写入到内存中

在上述代码中对a值的操作没有同步，可能会出现 t1线程先读取a，这个时候a=6，在+1之后就是a=7，但是没有执行到第三步把最新的值写在内存中就切换了t2线程来执行，t2读取到值仍然是6。

我们使用synchronized关键字之后看看效果

这个时候控制台输出的就是我们预期的值了 。

说说synchronized的两个用法

1. 对象锁:  包含了普通方法锁（锁对象当前实例对象） 和 同步代码块锁（指定的锁对象）
2. 类锁: 静态方法锁和class对象锁(同步代码块中 .class)

对象锁----> 同步代码块示例

public class ThreadDemo5 implements Runnable{

    static Object lock = new Object();

    @Override
    public void run() {
        // 使用对象lock
        synchronized (lock){
//          // 使用this 当前对象
//        synchronized (this){
            System.out.println("代码块锁 start , 线程名称: " + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("代码块锁 end , 线程名称: " + Thread.currentThread().getName());
        }
    }

    /**
     * 对象锁   同步代码块示例
     * @param args
     */
    public static void main(String[] args) {
        ThreadDemo5 temp = new ThreadDemo5();
        Thread t1 = new Thread(temp);
        Thread t2 = new Thread(temp);
        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()){

        }
        System.out.println("主线程 end !!!");
    }
}

结果

对象锁---> 普通方法示例

public class ThreadDemo5 implements Runnable{

    @Override
    public void run() {
        test();
    }

    /**
     * 方法加上  synchronized
     */
    public synchronized void test(){
        System.out.println("普通方法锁 start , 线程名称: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("普通方法锁 end , 线程名称: " + Thread.currentThread().getName());
    }

  
    public static void main(String[] args) {
        ThreadDemo5 temp = new ThreadDemo5();
        Thread t1 = new Thread(temp);
        Thread t2 = new Thread(temp);
        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()){

        }
        System.out.println("主线程 end !!!");
    }

执行结果

切记 对象锁使用的锁是同一个对象，如果使用不同对象是没有同步的效果

类锁--->静态方法示例

public class ThreadDemo5 implements Runnable{

    @Override
    public void run() {
        test();
    }

    /**
     * 静态方法加上  synchronized
     */
    public synchronized static void test(){
        System.out.println("静态方法锁 start , 线程名称: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("静态方法锁 end , 线程名称: " + Thread.currentThread().getName());
    }


    public static void main(String[] args) {
        // 使用两个实例
        ThreadDemo5 temp1 = new ThreadDemo5();
        ThreadDemo5 temp2 = new ThreadDemo5();
        Thread t1 = new Thread(temp1);
        Thread t2 = new Thread(temp2);
        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()){

        }
        System.out.println("主线程 end !!!");
    }
}

执行结果

类锁-->同步代码块示例

public class ThreadDemo5 implements Runnable{

    @Override
    public void run() {
        // ThreadDemo5.class 类锁
        synchronized (ThreadDemo5.class){
            System.out.println("代码块类锁 start , 线程名称: " + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("代码块类锁 end , 线程名称: " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        // 使用两个实例
        ThreadDemo5 temp1 = new ThreadDemo5();
        ThreadDemo5 temp2 = new ThreadDemo5();
        Thread t1 = new Thread(temp1);
        Thread t2 = new Thread(temp2);
        t1.start();
        t2.start();

        while (t1.isAlive() || t2.isAlive()){

        }
        System.out.println("主线程 end !!!");
    }
}

// 输出结果

类锁同一个对象或两个对象都会达到同步效果

 

 面试常问多线程访问同步方法的几种情况

1.两个线程同时访问一个对象的普通同步方法？

答： 具有同步效果

2.两个线程访问的是两个对象的普通同步方法？

答: 不具有同步效果，因为普通同步方法是对象锁，两个对象使用的锁对象不是同一个呀

3.两个线程访问的是synchronized的静态方法

答：具有同步效果，同步静态方法是类锁，锁的是类对象

4.两个线程访问一个对象同步方法与非同步方法

答: 会并行的执行，synchronized只作用在修饰的方法上面，非同步的方法是不受到影响的

5.访问同一个对象的不同的普通同步方法

答: 具有同步效果，普通同步方法锁都是同一个对象，所有会有同步效果

6.同时访问一个对象静态synchronized和非静态synchronized方法

答: 不具有同步效果，一个是类锁一个是对象锁，同时访问是不受到影响的