图片上传 密码修改为 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
相关文章
- 64M VPS建站：怎样选择合适的域名和SSL证书？ 2025-06-10
- 64M VPS建站：怎样优化以提高网站加载速度？ 2025-06-10
- 64M VPS建站：是否适合初学者操作和管理？ 2025-06-10
- ASP.NET自助建站系统中的用户注册和登录功能定制方法 2025-06-10
- ASP.NET自助建站系统的域名绑定与解析教程 2025-06-10
