Java的synchronized关键字

JBM2029

已于 2023-02-25 17:24:22 修改

阅读量73

点赞数

分类专栏： JavaSE 文章标签： java Powered by 金山文档

于 2023-02-24 21:22:39 首次发布

本文链接：https://blog.csdn.net/weixin_41885108/article/details/129207678

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章详细介绍了Java中的synchronized关键字，用于实现线程同步。通过两个实例展示了对象锁的使用，包括同步方法和同步代码块，强调了不同锁对象对并发执行的影响。此外，还提到了方法锁，即用synchronized修饰普通方法的情况。

摘要由CSDN通过智能技术生成

(90条消息) Java多线程(12)——synchronized详解_有鹿如溪的博客-CSDN博客

Synchronized的应用

一把锁只能同时被一个线程获取，没有获取锁的线程只能等待；每个实例都对应有自己的的一把锁（this），不同实例之间互不影响。

对象锁

包括方法所（默认锁对象是this，当前实例对象）和同步代码块锁（自己制定锁对象）

代码形式：手动指定锁对象，可以是this，也可以是自定义的锁

实例1：

public class PSY implements Runnable {
    static PSY instance = new PSY();
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
    }

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

实例2；

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instence = new SynchronizedObjectLock();
    // 创建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结束

方法锁形式；synchronized修饰普通方法，锁对象默认为this

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

    @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 t1 = new Thread(instence);
        Thread t2 = new Thread(instence);
        t1.start();
        t2.start();
    }
}
  
输出结果： 

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