多线程与锁：（三）synchronized

引用自：http://blog.iluckymeeting.com/2018/01/06/threadandlockthree/

什么是synchronized加锁

synchronized是Java语言的关键字，它加的是语言级的锁，被synchronized声明的代码块被加锁后将具有以下特性：

  • 原子互斥性 被synchronized声明的代码块一次只能被一个线程执行，其它线程必须等获得锁的线程执行完成后才能再次加锁执行同步代码块
  • 可见性 锁是加在某一个对象实例上的，如果有多个同步代码块在同一个对象上加锁，则各同步代码块中做的修改将相互可见

在JDK1.6以前synchronized通过对象监视器(Monitor)来加重量级锁，经过JDK1.6的优化引入了偏向锁和轻量级锁，提高了synchronized加锁的效率。

synchronized加锁的优势与不足

  • synchronized加的是非公平锁，效率上优于公平锁，由JVM保证所有申请锁的线程都有机会获得锁
  • synchronized锁的释放是由JVM管理的，即使是同步代码块中抛出了异常，也能保证锁最终会被释放，这样可以避免人为失误造成锁未被释放从而导致死锁
  • synchronized加锁后，JVM在做线程转储时会包含锁信息，这一点对于调试工作非常有帮助
  • 等待获得sychronized锁的线程无法被中断，也不能通过投票获得锁，这将消耗更多的资源来做线程调度

synchronized加锁用法

方式 作用范围 作用对象
代码块 代码块 调用代码块的对象
方法 方法 调用方法的对象
静态方法 静态方法 类的所有对象
类 括号里的内容 类的所有对象
对象实例 对象本身 具体对象

代码块加锁

public class Demo {

    public void invoke() {
        synchronized (this) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " started");
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {

            }
            System.out.println(threadName + " ended");
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Demo demo = new Demo();
                Thread.currentThread().setName("thread" + final_i);
                demo.invoke();
            });
            t.start();
        }
    }
}

运行结果如下：

thread0 started
thread1 started
thread2 started
thread2 ended
thread0 ended
thread1 ended

从运行结果上可以看出，3个线程的执行是没有阻塞的，代码块上的synchronized锁没起作用，为什么呢？因为synchronized声明的代码块声明时使用的this对象，所以这个代码块的锁是加在Demo类的对象上的，而这3个线程各自实例化了一个Demo类的对象，每个线程申请的锁都是加在不同对象上的锁，所以不会阻塞。
将上面的代码修改一下，让3个线程申请同一个Demo类实例对象上的锁：

public static void main(String[] args) {
        Demo demo = new Demo();
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Thread.currentThread().setName("thread" + final_i);
                demo.invoke();
            });
            t.start();
        }
    }

再次运行一下，结果如下：

thread0 started
thread0 ended
thread2 started
thread2 ended
thread1 started
thread1 ended

可以看出修改后3个线程是依次执行的，synchronized锁生效了

方法加锁

public class Demo {

    public synchronized void invoke() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " started");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            
        }
        System.out.println(threadName + " ended");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Thread.currentThread().setName("thread" + final_i);
                Demo demo = new Demo();
                demo.invoke();
            });
            t.start();
        }
    }
}

运行后的输出：

thread0 started
thread1 started
thread2 started
thread1 ended
thread0 ended
thread2 ended

从输出上可以看出synchronized加锁并没有影响3个线程的执行，为什么呢？因为方法声明上加synchronized锁时，加锁对象是Demo类实例化后的对象，在上面3个线程中每个线程都实例化了一个Demo类的对象，所以锁是加在不同的对象上的,每个线程申请的都是不同的锁，自然不会影响三个线程的执行;将上面的代码修改一下，使3个线程使用同一个Demo类的实例对象，再次运行看一下结果。将main方法修改如下，其它代码不变：

public static void main(String[] args) {
        Demo demo = new Demo();
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Thread.currentThread().setName("thread" + final_i);
                demo.invoke();
            });
            t.start();
        }
    }

运行结果如下：

thread0 started
thread0 ended
thread2 started
thread2 ended
thread1 started
thread1 ended

从运行结果上可以看出，3个线程是依次执行的，synchronized加的锁起作用了

静态方法加锁

public class Demo {

    public synchronized static void invoke() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " started");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {

        }
        System.out.println(threadName + " ended");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Thread.currentThread().setName("thread" + final_i);
                Demo.invoke();
            });
            t.start();
        }
    }
}

运行结果如下：

thread0 started
thread0 ended
thread2 started
thread2 ended
thread1 started
thread1 ended

由结果可以看出3个线程是顺序执行的，这是因为加锁的方法是静态方法，所有的方法调用申请加锁是使用的同一个锁，不论Demo类实例化了多少个对象。

类加锁

还是上面用到的代码块加锁，修改成如下：

public class Demo {

    public void invoke() {
        synchronized (Demo.class) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " started");
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {

            }
            System.out.println(threadName + " ended");
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Demo demo = new Demo();
                Thread.currentThread().setName("thread" + final_i);
                demo.invoke();
            });
            t.start();
        }
    }
}

运行结果如下：

thread0 started
thread0 ended
thread2 started
thread2 ended
thread1 started
thread1 ended

可以看出3个线程是按顺序执行的，锁生效了，可是3个线程都实例化了一个自己的demo对象，为什么会这样？这是因为加锁的对象变了，

synchronized(this)

这种加锁方式会把锁加在Demo类的实例对象上，如果创建多个Demo类的实例对象就会相应的在每个对象上加锁，而这里用的是

synchronized(Demo.class)

这种加锁方式，此时无论Demo被实例出多少个对象，它们用的都是同一把锁，所以3个线程是顺序执行的。

对象实例加锁

public class Demo {
    private ReentrantLocker lock = new ReentrantLocker();

    public void invoke() {
        synchronized (lock) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " started");
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {

            }
            System.out.println(threadName + " ended");
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            int final_i = i;
            Thread t = new Thread(() -> {
                Demo demo = new Demo();
                Thread.currentThread().setName("thread" + final_i);
                demo.invoke();
            });
            t.start();
        }
    }
}

运行结果如下：

thread2 started
thread1 started
thread0 started
thread2 ended
thread1 ended
thread0 ended

可以看出3个线程并没有竞争同一个锁，这是因为每个Demo实例对象都有一个lock对象，所以每个线程都申请了不同的锁;
修改一下代码，将lock对象声明改成下面这样

    private static ReentrantLocker lock = new ReentrantLocker();

再次运行结果如下：

thread0 started
thread0 ended
thread2 started
thread2 ended
thread1 started
thread1 ended

3个线程是按顺序执行的了，为什么呢？因为lock对象被声明成了static静态对象，虽然Demo被实例出了多个对象，但是它们使用的lock对象是同一个，所以3个线程申请的锁是加在同一个对象上的。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • Android 面试之 Java 篇三
    本文出自 Eddy Wiki ，转载请注明出处：http://eddy.wiki/interview-java.h...
    eddy_wiki阅读 6,648评论 0赞 14
  • java并发与多线程
    1.解决信号量丢失和假唤醒 public class MyWaitNotify3{ MonitorObject m...
    Q罗阅读 4,451评论 0赞 1
  • 面试知识点1
    Java8张图 11、字符串不变性 12、equals()方法、hashCode()方法的区别 13、...
    Miley_MOJIE阅读 9,158评论 0赞 11
  • Java基础——有点闹的线程和进程
    一、进程和线程 进程 进程就是一个执行中的程序实例，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。...
    阿敏其人阅读 7,410评论 0赞 13
  • 关于生命的喜怒无常
    或许只要没有大事发生，或者有，也没在我们身边，我们会感觉生活还是很美好的，但是由于最近生病住院，恍然间才发现原来生...
    陈许儿阅读 3,443评论 0赞 0

友情链接更多精彩内容