一、 synchronized关键字
1.对象锁
a.当使用对象锁的时候，注意要是相同的对象，并且当有线程正在访问对象锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)。
b.但是并不影响没有使用对象锁的部分的代码的运行。
对象锁分为两类一个叫做synchronized代码块(圆括号内是普通类的对象)，另外一个是sybchronized修饰普通成员方法。它们二者其实可以通过this关键字进项转化。
2.类锁
a. 当使用类锁的时候，只要是同一个类的对象.当有线程正在访问类锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)
b. 但是并不影响没有使用类锁的部分的代码的运
对象锁分为两类一个叫做synchronized代码块(圆括号内是class对象)，另外一个是sybchronized修饰静态成员方法。它们二者其实可以通过class对象进项转化。
注意: 类锁和对象锁之间没有关系.
1、不使用线程锁
如果没有加synchronized关键字，会产生线程交错运行
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
/**
* 该类写了一个test方法，先不加synchronized关键字
*/
public class A {
void test() {
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
}
}
/**
* 该类继承Thread，重写run方法调用A中的test方法
*/
public class MyThread1 extends Thread{
A a;
public void run() {
a.test();
}
}
/**
* 该类继承Thread，重写run方法调用A中的test方法
*/
public class MyThread2 extends Thread{
A a;
public void run() {
a.test();
}
}
/**
* 测试程序
* /
public class Entrance {
public static void main(String[] args) {
/**
* 演示没有锁时会产生交错现象
*/
A a = new A();
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
t1.a = a;
t2.a = a;
t1.start();
t2.start();
}
}
产生如下运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：0
线程：5
线程：6
线程：7
线程：8
线程：9
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
|
2、使用对象锁
将A类中test方法代码改成如下代码，其他不变，运行测试类可以产生如下结果
|
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
35
36
37
38
39
40
41
42
43
|
/**
* 该类写了一个test方法，使用对象锁
* 分别在锁前锁后增加代码，演示对没有使用对象锁的代码不会产生任何影响
* 且如果对象锁被锁住，对象锁后面的代码是不会运行的
*/
public class A {
void test() {
System.out.println("线程开始");
synchronized(this) {
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
}
System.out.println("线程结束");
}
}
运行测试类会产生如下结果：（注意：”线程开始“不是在对象锁中的内容）
线程开始
线程：0
线程：1
线程开始
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程结束
线程：7
线程：8
线程：9
线程结束
|
使用synchronized直接修饰方法等价于synchronized(this)修饰方法内的全部代码
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
/**
* synchronized直接修饰方法等价于synchronized(this)修饰方法内的全部代码
* test和test1方法是等价的
*/
public class A {
synchronized void test() {
System.out.println("线程开始");
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
System.out.println("线程结束");
}
void test1() {
synchronized (this) {
System.out.println("线程开始");
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
System.out.println("线程结束");
}
}
}
其他代码是一样的，在MyThread1和MyThread2中无论调用test还是test1，结果是一样的，如下：
线程开始
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程结束
线程开始
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程结束
|
对象锁对不同的方法也是有用的（类锁也是如此）
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
/**
* 类锁对不同的方法也是有用的
*/
public class A {
// synchronized void test() {
// for(int i=0;i<10;i++) {
// System.out.println("方法test："+i);
// }
// }
void test() {
synchronized(this) {
for(int i=0;i<10;i++) {
System.out.println("方法test："+i);
}
}
}
// synchronized void test1() {
// for(int i=0;i<10;i++) {
// System.out.println("方法test1："+i);
// }
// }
void test1() {
synchronized(this) {
for(int i=0;i<10;i++) {
System.out.println("方法test1："+i);
}
}
}
}
MyThread1中调用test方法，MyThread2中调用test1方法，运行结果如下：
方法test：0
方法test：1
方法test：2
方法test：3
方法test：4
方法test：5
方法test：6
方法test：7
方法test：8
方法test：9
方法test1：0
方法test1：1
方法test1：2
方法test1：3
方法test1：4
方法test1：5
方法test1：6
方法test1：7
方法test1：8
方法test1：9
|
3、使用类锁
演示当A类中的test方法使用对象锁时，不同对象调用test方法时对象锁是起不到任何作用的
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
/**
* 该类写了一个test方法，使用对象锁演示不用对象调用test方法
*/
public class A {
void test() {
synchronized(this) {
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
}
}
}
MyThread1和MyThread2是一样的，主要在测试程序的不同
测试程序：
public class Entrance {
public static void main(String[] args) {
/**
* 演示使用不同的对象调用test方法时，对象锁会产生交错现象
* 而使用类锁则不会产生这种现象
*/
A a1 = new A();
A a2 = new A();
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
t1.a = a1;
t2.a = a2;
t1.start();
t2.start();
}
}
运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：0
线程：5
线程：6
线程：7
线程：8
线程：9
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
|
使用类锁会改变这种情况，无论是那个对象，只要调用的是同一个方法就会产生锁
|
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
35
36
|
/**
* 该类写了一个test方法，使用对象锁演示不用对象调用test方法
* 将类A中的this改为A.class,其他代码都不变
*/
public class A {
void test() {
synchronized(A.class) {
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
}
}
}
运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
|
对象锁分为两类一个叫做synchronized代码块(圆括号内是普通类的对象)，另外一个是sybchronized修饰普通成员方法。它们二者其实可以通过this关键字进项转化。
|
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
35
36
|
/**
* 该类写了一个test方法，使用对象锁演示不用对象调用test方法
* 将类A中的this改为A.class,其他代码都不变
*/
public class A {
void test() {
synchronized(A.class) {
for(int i=0;i<10;i++) {
System.out.println("线程："+i);
}
}
}
}
运行结果：
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
线程：0
线程：1
线程：2
线程：3
线程：4
线程：5
线程：6
线程：7
线程：8
线程：9
|
类锁这对象锁之间是没有任何关系，互不影响互不干涉
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
/**
* 该类写了test方法使用对象锁，写了test1方法使用类锁
*/
public class A {
synchronized void test() {
for(int i=0;i<10;i++) {
System.out.println("方法test："+i);
}
}
synchronized static void test1() {
for(int i=0;i<10;i++) {
System.out.println("方法test1："+i);
}
}
}
MyThread1调用test方法，使用对象锁，MyThread2调用test1方法，使用类锁
测试程序
public class Entrance {
public static void main(String[] args) {
A a1 = new A();
A a2 = new A();
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
/*
使用同一个对象调用test和test1会产生交错现象
使用不同对象调用test和test1也会产生交错现象
*/
// t1.a = a1;
// t2.a = a1;
t1.a = a1;
t2.a = a2;
t1.start();
t2.start();
}
}
运行结果：
方法test：0
方法test：1
方法test1：0
方法test1：1
方法test1：2
方法test1：3
方法test1：4
方法test1：5
方法test1：6
方法test1：7
方法test1：8
方法test1：9
方法test：2
方法test：3
方法test：4
方法test：5
方法test：6
方法test：7
方法test：8
方法test：9
|
到此这篇关于Java基础之线程锁相关知识总结的文章就介绍到这了,更多相关Java线程锁内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/qq_46307070/article/details/117901446