JAVA关键字Synchronized的使用

JAVA关键字Synchronized的使用

在使用synchronized关键字的时候需要注意

• 一把锁只能同时被一个线程持有，没有获取到锁的线程进行等待
• 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
• synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

Java中的每一个对象都可以作为锁，具体表现有以下3种形式

锁分为两种，对象锁和类锁

对象锁

两种实现方式，同步代码块锁和方法锁（非静态方法），方法锁默认锁对象是this

同步代码块

手动指定锁对象

• 使用this作为锁对象

public class CodeBlockLockDemo1 implements Runnable{
    static CodeBlockLockDemo1 instence = new CodeBlockLockDemo1();

    @Override
    public void run() {
        // 同步代码块形式——锁为this,两个线程使用的锁是一样的,线程1必须要等到线程0释放了该锁后，才能执行
        synchronized (this) {
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }

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

输出结果：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

• 使用指定对象作为锁

public class CodeBlockLockDemo2 implements Runnable{
    static CodeBlockLockDemo2 instence = new CodeBlockLockDemo2();
    // 创建2把锁
    Object block1 = new Object();
    Object block2 = new Object();

    @Override
    public void run() {
        // 这个代码块使用的是第一把锁，当他释放后，后面的代码块由于使用的是第二把锁，因此可以马上执行
        synchronized (block1) {
            System.out.println("block1锁,我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("block1锁,"+Thread.currentThread().getName() + "结束");
        }

        synchronized (block2) {
            System.out.println("block2锁,我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("block2锁,"+Thread.currentThread().getName() + "结束");
        }
    }

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

输出结果：

block1锁,我是线程Thread-0
block1锁,Thread-0结束
block2锁,我是线程Thread-0
block1锁,我是线程Thread-1
block2锁,Thread-0结束
block1锁,Thread-1结束
block2锁,我是线程Thread-1
block2锁,Thread-1结束

指定对象作为锁时，不同的对象就是一把不同的锁，看上面代码的输出结果就知道，Thread-1中第一段代码块执行后，第二段代码块立马执行了，应该两个用了不同的锁

方法锁（非静态方法）

public class MethodLockDemo implements Runnable{
    static MethodLockDemo instence = new MethodLockDemo();

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

    public synchronized void method(){
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instence);
        Thread thread2 = new Thread(instence);
        thread1.start();
        thread2.start();
    }
}

输出结果：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

类锁

synchronize修饰静态的方法或指定锁对象为Class对象

修饰静态方法

public class StaticMethodLockDemo implements Runnable{
    static StaticMethodLockDemo instence1 = new StaticMethodLockDemo();
    static StaticMethodLockDemo instence2 = new StaticMethodLockDemo();

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

    // synchronized用在静态方法上，默认的锁就是当前所在的Class类，所以无论是哪个线程访问它，需要的锁都只有一把
    public static synchronized void method(){
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        // t1和t2对应的this是两个不同的实例，所以代码不会串行
        Thread t1 = new Thread(instence1);
        Thread t2 = new Thread(instence2);
        t1.start();
        t2.start();
    }
}

输出结果：

我是线程Thread-1
Thread-1结束
我是线程Thread-0
Thread-0结束

上面这段代码执行结果会发现，无论哪一个线程访问这个类，都会只存在一把锁。

指定类锁对象为Class对象

public class ClassLockDemo implements Runnable{
    static ClassLockDemo instence1 = new ClassLockDemo();
    static ClassLockDemo instence2 = new ClassLockDemo();

    @Override
    public void run() {
        // 所有线程需要的锁都是同一把
        synchronized(ClassLockDemo.class){
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instence1);
        Thread t2 = new Thread(instence2);
        t1.start();
        t2.start();
    }
}

输出结果：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束