在Java中,synchronized关键字是用来控制线程同步的,就是在多线程的环境下,控制synchronized代码段不被多个线程同时执行。synchronized既可以加在一段代码上,也可以加在方法上。
关键是,不要认为给方法或者代码段加上synchronized就万事大吉,看下面一段代码:
- public synchronized void test() {
- System.out.println("test开始..");
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("test结束..");
- }
- }
- class MyThread extends Thread {
- public void run() {
- Sync sync = new Sync();
- sync.test();
- }
- }
- public class Main {
- public static void main(String[] args) {
- for (int i = 0; i < 3; i++) {
- Thread thread = new MyThread();
- thread.start();
- }
- }
- }
class Sync { public synchronized void test() { System.out.println("test开始.."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("test结束.."); } } class MyThread extends Thread { public void run() { Sync sync = new Sync(); sync.test(); } } public class Main { public static void main(String[] args) { for (int i = 0; i < 3; i++) { Thread thread = new MyThread(); thread.start(); } } }
运行结果: test开始.. test开始.. test开始.. test结束.. test结束.. test结束..
可以看出来,上面的程序起了三个线程,同时运行Sync类中的test()方法,虽然test()方法加上了synchronized,但是还是同时运行起来,貌似synchronized没起作用。
将test()方法上的synchronized去掉,在方法内部加上synchronized(this):
- public void test() {
- synchronized(this){
- System.out.println("test开始..");
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("test结束..");
- }
- }
public void test() { synchronized(this){ System.out.println("test开始.."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("test结束.."); } }
运行结果: test开始.. test开始.. test开始.. test结束.. test结束.. test结束..
一切还是这么平静,没有看到synchronized起到作用。
实际上,synchronized(this)以及非static的synchronized方法(至于static synchronized方法请往下看),只能防止多个线程同时执行同一个对象的同步代码段。
回到本文的题目上:synchronized锁住的是代码还是对象。答案是:synchronized锁住的是括号里的对象,而不是代码。对于非static的synchronized方法,锁的就是对象本身也就是this。
当synchronized锁住一个对象后,别的线程如果也想拿到这个对象的锁,就必须等待这个线程执行完成释放锁,才能再次给对象加锁,这样才达到线程同步的目的。即使两个不同的代码段,都要锁同一个对象,那么这两个代码段也不能在多线程环境下同时运行。
所以我们在用synchronized关键字的时候,能缩小代码段的范围就尽量缩小,能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度,使代码更大程度的并发。原因是基于以上的思想,锁的代码段太长了,别的线程是不是要等很久,等的花儿都谢了。当然这段是题外话,与本文核心思想并无太大关联。
再看上面的代码,每个线程中都new了一个Sync类的对象,也就是产生了三个Sync对象,由于不是同一个对象,所以可以多线程同时运行synchronized方法或代码段。
为了验证上述的观点,修改一下代码,让三个线程使用同一个Sync的对象。
- class MyThread extends Thread {
- private Sync sync;
- public MyThread(Sync sync) {
- this.sync = sync;
- }
- public void run() {
- sync.test();
- }
- }
- public class Main {
- public static void main(String[] args) {
- Sync sync = new Sync();
- for (int i = 0; i < 3; i++) {
- Thread thread = new MyThread(sync);
- thread.start();
- }
- }
- }
class MyThread extends Thread { private Sync sync; public MyThread(Sync sync) { this.sync = sync; } public void run() { sync.test(); } } public class Main { public static void main(String[] args) { Sync sync = new Sync(); for (int i = 0; i < 3; i++) { Thread thread = new MyThread(sync); thread.start(); } } }
运行结果: test开始.. test结束.. test开始.. test结束.. test开始.. test结束..
可以看到,此时的synchronized就起了作用。
那么,如果真的想锁住这段代码,要怎么做?也就是,如果还是最开始的那段代码,每个线程new一个Sync对象,怎么才能让test方法不会被多线程执行。
解决也很简单,只要锁住同一个对象不就行了。例如,synchronized后的括号中锁同一个固定对象,这样就行了。这样是没问题,但是,比较多的做法是让synchronized锁这个类对应的Class对象。
- class Sync {
- public void test() {
- synchronized (Sync.class) {
- System.out.println("test开始..");
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("test结束..");
- }
- }
- }
- class MyThread extends Thread {
- public void run() {
- Sync sync = new Sync();
- sync.test();
- }
- }
- public class Main {
- public static void main(String[] args) {
- for (int i = 0; i < 3; i++) {
- Thread thread = new MyThread();
- thread.start();
- }
- }
- }
class Sync { public void test() { synchronized (Sync.class) { System.out.println("test开始.."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("test结束.."); } } } class MyThread extends Thread { public void run() { Sync sync = new Sync(); sync.test(); } } public class Main { public static void main(String[] args) { for (int i = 0; i < 3; i++) { Thread thread = new MyThread(); thread.start(); } } }
运行结果: test开始.. test结束.. test开始.. test结束.. test开始.. test结束..
上面代码用synchronized(Sync.class)实现了全局锁的效果。
static synchronized方法,static方法可以直接类名加方法名调用,方法中无法使用this,所以它锁的不是this,而是类的Class对象,所以,static synchronized方法也相当于全局锁,相当于锁住了代码段。
相关推荐
在Java中,synchronized关键字是用来控制线程同步的,是在多线程的环境下,控制synchronized代码段不被多个线程同时执行。Synchronized既可以对代码块使用,也可以加在整个方法上。 关键是,不要认为给方法或者...
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制,用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字,可以锁住当前...
Java synchronized锁住的对象解析 在Java编程中,synchronized关键字是用于同步的关键字,它可以用于锁住一个对象,以实现线程同步。但是,在使用synchronized关键字时,需要了解锁住的到底是哪个对象,否则可能...
首先,我们需要理解synchronized锁住的是对象,而不是代码块。例如,当我们使用`synchronized (o)`对一个对象o进行加锁时,实际上是对o这个对象本身进行锁定,而不是对包围的代码块。这个过程通过修改对象的内部状态...
在学习Java过程中,自己收集了很多的Java的学习资料,分享给大家,有需要的欢迎下载,希望对大家有用,一起学习,一起进步。
首先,需要清晰的是 synchronized 锁住的不是代码而是对象。在编写相关的代码块时要留意线程同步平安问题。synchronized 代码块被修饰的代码称为同步语句块,其作用范围是调用这个代码块的对象。我们在使用 ...
除了锁住对象或类,`synchronized`还可以与`wait()`、`notify()`和`notifyAll()`方法结合使用,实现复杂的线程通信和同步。这些方法都是在`Object`类中定义的,只有在持有对象锁的情况下才能调用,否则会抛出`...
- `synchronized`可以修饰实例方法,此时锁住的是对象实例。如果两个线程分别持有同一对象的不同实例,它们可以同时执行各自实例上的同步方法,互不影响。但如果两个线程试图访问同一对象的同步方法,其中一个线程...
- 锁住的对象应该是线程安全的,否则可能会引发数据不一致问题。 - 零长度的`byte[]`数组作为锁对象是一种优化手段,因为它的创建成本较低。 总之,Java的`synchronized`机制提供了一种有效的方式来管理多线程...
2. **synchronized 方法**:当`synchronized`关键字应用于方法时,整个方法体被视为同步代码块,作用对象是调用该方法的对象。对于非静态方法,锁住的是实例对象;对于静态方法,锁住的是类的Class对象,即全局锁。 ...
从性能角度考虑,同步代码块通常优于同步方法,因为它们只锁住必要的代码区域,而不是整个方法。这减少了死锁和资源竞争的可能性,提高了程序的并发性能。然而,选择同步代码块还是同步方法取决于实际需求,如果需要...
- **锁对象**:synchronized有两种使用方式:修饰实例方法(锁住当前实例对象)和修饰静态方法(锁住类的Class对象)。 - **监视器锁**:每个对象都有一个内置的监视器锁,synchronized就是基于这个锁来实现同步的...
1. **类级别锁(Class-Level Lock)**:当`synchronized`修饰静态方法或静态代码块时,锁住的是整个类的Class对象。这意味着,无论实例化了多少个对象,只有一个线程可以执行静态同步代码,适用于所有实例共享的资源...
例如,如果将 synchronized 锁住的是不同对象的方法,那么依然是线程不安全的。 sychronized 关键字可以用于修饰方法和代码块两种形式。例如,在方法上使用 synchronized 关键字,可以保障该方法在同一时间只能被...
值得注意的是,当一个对象被锁住时,该对象内部所有用 `Synchronized` 修饰的方法都会受到影响而被阻塞,除非它们是非 `Synchronized` 方法。 **问题三:什么是可重入性,为什么说 `Synchronized` 是可重入锁?** ...
用在代码块上,锁住的是 synchronized() 里的对象。在 JDK6 之前,synchronized 使用的是重量级锁制,在之后 synchronized 加入了锁膨胀机制,显著提升了 synchronized 关键字的效率。 基于 synchronized 关键字,...
* 锁住对象本身:public void print() {synchronized(this) {...;}} * 锁住对象的成员变量:private String a = "test"; public void print() {synchronized(a) {...;}} 2. 使用 volatile 变量 volatile 变量可以...
对象锁只锁住当前对象,不影响其他对象实例。这意味着,即使多个线程同时访问同一类的不同实例,它们也不会相互阻塞,因为每个实例都有自己的锁。 1. synchronized修饰普通方法: 当一个方法被`synchronized`修饰...
锁住的对象可以是实例变量或类的静态变量。例如: ```java public class MyClass { public int sharedVar; public int syncBlock(int a1) { synchronized (a1) { // 一次只有一个线程可以执行此代码块 } }...
`this`关键字代表当前对象实例,锁住的是调用方法的对象。 2. **synchronized 修饰代码块** 使用`synchronized`修饰代码块,可以指定锁定的对象,这给了我们更大的灵活性。例如,我们可以根据需要锁定某个对象,...