gpt4 book ai didi

解析Java编程之Synchronized锁住的对象

转载 作者:qq735679552 更新时间:2022-09-28 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章解析Java编程之Synchronized锁住的对象由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.

图片上传 密码修改为  synchronized是java中用于同步的关键字,一般我们通过Synchronized锁住一个对象,来进行线程同步。我们需要了解在程序执行过程中,synchronized锁住的到底是哪个对象,否则我们在多线程的程序就有可能出现问题.

看下面的代码,我们定义了一个静态变量n,在run方法中,我们使n增加10,然后在main方法中,我们开辟了100个线程,来执行n增加的操作,如果线程没有并发执行,那么n最后的值应该为1000,显然下面的程序执行完结果不是1000,因为我们没有进行线程同步.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.concurrent.TimeUnit;
public class SynchronizedTest1 extends Thread {
   public static int n = 0 ;
   public void run() {
     try {
       //使n自加10次
       for ( int i = 0 ; i < 10 ; i++) {
         n = n + 1 ;
         TimeUnit.MILLISECONDS.sleep( 10 );
       }
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }
   public static void main(String[] args) throws InterruptedException {
     Thread[] threads = new Thread[ 100 ];
     for ( int i = 0 ; i < threads.length; i++) {
       threads[i] = new SynchronizedTest1();
       threads[i].start();
     }
     //使所有其他线程执行完,再继续执行main线程,这样得出的n是最终的结果
     for (Thread thread : threads) {
       thread.join();
     }
     System.out.println(n);
   }
}

为了实现同步,我们修改上面的代码,增加一个increase方法,如下。但是当我们执行下面的代码时,会发现n仍然不是1000. 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.concurrent.TimeUnit;
public class SynchronizedTest2 extends Thread {
   public static int n = 0 ;
   public synchronized void increase() {
     n++;
   }
   public void run() {
     try {
       //使n自加10次
       for ( int i = 0 ; i < 10 ; i++) {
         increase();
         TimeUnit.MILLISECONDS.sleep( 10 );
       }
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }
   public static void main(String[] args) throws InterruptedException {
     Thread[] threads = new Thread[ 100 ];
     for ( int i = 0 ; i < threads.length; i++) {
       threads[i] = new SynchronizedTest2();
       threads[i].start();
     }
     //使所有其他线程执行完,再继续执行main线程,这样得出的n是最终的结果
     for (Thread thread : threads) {
       thread.join();
     }
     System.out.println(n);
   }
}

其实原因很简单,上面的多个线程在执行时根本就没有竞争同一个对象锁。当我们执行用synchronized修饰的非静态方法时,线程会首先获得调用这个方法的对象的锁,然后才能继续执行代码。那么调用这个方法的到底是哪个对象,是this对象。在上面的例子中,thread[i]所代表的线程获取的锁对象是thread[i]对象,也就是该线程对象本身。因此上面所开辟的100个线程只要获得自身对象就可以执行,这样就使同步失去了作用.

我们再次修改代码:即将increase方法改为i静态的,此时程序执行完后n的值为1000.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import java.util.concurrent.TimeUnit;
 
public class SynchronizedTest3 extends Thread {
   public static int n = 0 ;
 
   public synchronized static void increase() {
     n++;
   }
   public void run() {
     try {
       //使n自加10次
       for ( int i = 0 ; i < 10 ; i++) {
         increase();
         TimeUnit.MILLISECONDS.sleep( 10 );
       }
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }
 
   public static void main(String[] args) throws InterruptedException {
     Thread[] threads = new Thread[ 100 ];
     for ( int i = 0 ; i < threads.length; i++) {
       threads[i] = new SynchronizedTest3();
       threads[i].start();
     }
 
     //使所有其他线程执行完,再继续执行main线程,这样得出的n是最终的结果
     for (Thread thread : threads) {
       thread.join();
     }
     System.out.println(n);
   }
}

当synchronized 修饰static方法,它锁住的是该类的Class对象,而不是某一个具体对象。在上面的例子中,它锁住的就是SynchronizedTest3.class对象。在程序执行过程中,类的Class对象只有一份,所以上面线程竞争的是同一个对象锁.

下面是对synchronized锁住对象的总结:

(1)对于同步方法,锁当前对象(this) (2)对于静态同步方法,锁当前类的Class对象 (3)对于同步代码块,锁住的是synchronized括号中的对象 。

总结 。

以上就是本文关于解析Java编程之Synchronized锁住的对象的全部内容,希望对大家有所帮助。有什么问题可以直接留言,小编会及时回复大家的。希望大家能够喜欢.

原文链接:http://blog.csdn.net/zhangjk1993/article/details/23948429 。

最后此篇关于解析Java编程之Synchronized锁住的对象的文章就讲到这里了,如果你想了解更多关于解析Java编程之Synchronized锁住的对象的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com