synchronized 锁定的到底是什么

最新推荐文章于 2024-08-08 10:25:21 发布

原创最新推荐文章于 2024-08-08 10:25:21 发布 · 165 阅读

0 ·

CC 4.0 BY-SA版权

锁机制专栏收录该内容

3 篇文章

订阅专栏

本文通过实例详细解析了Java中synchronized关键字的用法及其锁定机制，包括非静态方法、静态方法及类级别的锁，并总结了不同场景下的锁作用范围。

java 的锁，常用是synchronized，(当然还有Lock，后续如果有时间，会补充到后面)，那么synchronized锁定的到底是什么呢？对象还是锁的是方法。

这里我暂时只说非static的例子，static的例子，后续会补充。

我们一般使用synchronized，以下两种

synchronized void test(){}

2）

void test(){

synchronized (?){

}}

在实际应用中，还是需要了解synchronized 到底是什么的，这有助于我们处理对业务需求。为了解决synchronized 到底是什么，请看一下代码?

我写一个锁定方法的例子:

public class Main {

public synchronized void test(int k){
try {
System.out.println("Thread "+k +" satrt");
Thread.sleep(10000);
System.out.println("Thread "+k +" end");
} catch (InterruptedException e) {
}
}

}

在写一个线程类

class Test1 extends Thread{

private int num=0;

public Test1(int num) {
this.num = num;
}

@Override
public void run() {
new Main().test(num);
}

}

我在Main 类加主main方法：

public class Main {

public static void main(String[] args) {
new Test1(1).start();
new Test1(2).start();
new Test1(3).start();
}

}

执行结果：

Thread 1 satrt
Thread 3 satrt
Thread 2 satrt
Thread 2 end
Thread 3 end
Thread 1 end

可见synchronized 没有生效，都执行了。没有按照我们的想法去做。

下面我对 synchronized 方法进行下修改：

public void test(int k){
synchronized(this){
try {
System.out.println("Thread "+k +" satrt");
Thread.sleep(10000);
System.out.println("Thread "+k +" end");
} catch (InterruptedException e) {
}
}
}

在执行结果：

Thread 1 satrt
Thread 2 satrt
Thread 3 satrt
Thread 1 end
Thread 3 end
Thread 2 end

没有任何改变，和我们期望的不一致。

我们对上面的类进行一下修改：

public class Main {
public static void main(String[] args) {
Main main = new Main();

new Test1(1,main).start();
new Test1(2,main).start();
new Test1(3,main).start();
}

public synchronized void test(int k){
try {
System.out.println("Thread "+k +" satrt");
Thread.sleep(10000);
System.out.println("Thread "+k +" end");
} catch (InterruptedException e) {
}
}
}

对线程类也做一点修改：

class Test1 extends Thread{

private int num=0;
private Main main;

public Test1(int num,Main main) {
this.num = num;
this.main =main;
}

@Override
public void run() {
main.test(num);
}

}

执行下得到结果：

Thread 1 satrt
Thread 1 end
Thread 3 satrt
Thread 3 end
Thread 2 satrt
Thread 2 end

这是我们期望看到的结果。

由此得出结论：对非static的synchronized 方法或者对象，都是只锁定该对象中的该方法，而不是锁定方法本身。

如果我们期望全局锁定方法，我们继续对上面的方法进行修改。

主类：

public class Main {

public static void main(String[] args) {
new Test1(1).start();
new Test1(2).start();
new Test1(3).start();
}

public static synchronized void test(int k){
try {
System.out.println("Thread "+k +" satrt");
Thread.sleep(10000);
System.out.println("Thread "+k +" end");
} catch (InterruptedException e) {
}
}
}

线程类：

class Test1 extends Thread{

private int num=0;

public Test1(int num) {
this.num = num;
}

@Override
public void run() {
test(num);
}

}

结果是：

Thread 1 satrt
Thread 1 end
Thread 3 satrt
Thread 3 end
Thread 2 satrt
Thread 2 end

这是我们期望的结果。

在做另外一种修改：

public class Main {

public static void main(String[] args) {
new Test1(1).start();
new Test1(2).start();
new Test1(3).start();
}

public void test(int k){
synchronized(Main.class){
try {
System.out.println("Thread "+k +" satrt");
Thread.sleep(10000);
System.out.println("Thread "+k +" end");
} catch (InterruptedException e) {
}
}
}
}