Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。
synchronized 关键字主要有以下几种用法:
- 非静态方法的同步;
- 静态方法的同步;
- 代码块。
下面分对象锁和类锁来分别说明 synchronized 用法:
1.对象锁 对象锁在一个类中可以有很多个
案例1:两个线程同时访问一个对象里的用synchronized关键字修饰的方 法
package com.zhu.threaddemo.synchronizedtest;
public class TestSynchronized {
public synchronized void minus() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
package com.zhu.threaddemo.synchronizedtest;
public class Run {
public static void main(String[] args) {
final TestSynchronized testSynchronized =new TestSynchronized();
//起两个线程
Thread thread1 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
Thread thread2 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
//启动线程
thread1.start();
thread2.start();
}
}
执行结果:
Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0
可以发现两个线程 thread1 和 thread2,同时访问对象的方法,由于该方法是 synchronized 关键字修饰的,那么这两个线程都需要获得该对象锁,一个获得后另一个线程必须等待。
(另:thread1 和 thread2 谁先执行并不一定)
本例对于对象锁进行了基础的解释。但是对象锁的范围是怎样的,对象的某个同步方法被一个线程访问后,其他线程能不能访问该对象的其他同步方法,以及是否可以访问对象的其他非同步方法呢,下面对两种进行验证:
案例2:在对象TestSynchronized中加一个用synchronized的方法
package com.zhu.threaddemo.synchronizedtest;
public class TestSynchronized {
public synchronized void minus() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
public synchronized void minus2() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
线程分别调用不同的同步方法
package com.zhu.threaddemo.synchronizedtest;
public class Run {
public static void main(String[] args) {
final TestSynchronized testSynchronized =new TestSynchronized();
//起两个线程
Thread thread1 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
Thread thread2 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus2();
}
});
//启动线程
thread1.start();
thread2.start();
}
}
结果为:
Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0
可以看到,某个线程得到了对象锁之后,该对象的其他同步方法是锁定的,其他线程是无法访问的。
案例2:是否能访问非同步方法呢
把对象TestSynchronized中的一个方法改成非同步的
package com.zhu.threaddemo.synchronizedtest;
public class TestSynchronized {
public synchronized void minus() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
public void minus2() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
执行结果为:
Thread-1 - 4
Thread-0 - 4
Thread-1 - 3
Thread-0 - 3
Thread-1 - 2
Thread-0 - 2
Thread-1 - 1
Thread-0 - 1
Thread-1 - 0
Thread-0 - 0
可以看到可以看到,结果是交替的,说明线程是交替执行的,说明如果某个线程得到了对象锁,但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法(加锁方法)和没有进行同步的方法(普通方法)是互不影响的,一个线程进入了同步方法,得到了对象锁,其他线程还是可以访问那些没有同步的方法(普通方法)。
2.类锁
类锁需要 synchronized 来修饰静态 static 方法,写法如下:
public static synchronized void test(){
// TODO
}
或者使用代码块,需引用当前的类:
public static void test(){
synchronized (TestSynchronized.class) {
// TODO
}
}
举例说明类锁的作用:
两个线程访问一个对象的一个用static修饰的synchronized方法
package com.zhu.threaddemo.synchronizedtest;
public class TestSynchronized1 {
public static synchronized void minus() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
package com.zhu.threaddemo.synchronizedtest;
public class Run1 {
public static void main(String[] args) {
final TestSynchronized1 testSynchronized =new TestSynchronized1();
//起两个线程
Thread thread1 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
Thread thread2 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
//启动线程
thread1.start();
thread2.start();
}
}
结果:
Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0
可以看到,类锁和对象锁其实是一样的,由于静态方法是类所有对象共用的,所以进行同步后,该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。
类锁的作用和对象锁类似,但是作用范围是否和对象锁一致呢,下面看对象锁和类锁是否等同:
修改类,两个同步方法,其中一个是静态的:
一个是类锁 一个是对象锁
package com.zhu.threaddemo.synchronizedtest;
public class TestSynchronized1 {
public static synchronized void minus() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
public synchronized void minus2() {
int count = 5;
for (int i = 0; i < 5; i++) {
count--;
System.out.println(Thread.currentThread().getName() + " - " + count);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
}
package com.zhu.threaddemo.synchronizedtest;
public class Run1 {
public static void main(String[] args) {
final TestSynchronized1 testSynchronized =new TestSynchronized1();
//起两个线程
Thread thread1 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus();
}
});
Thread thread2 =new Thread(new Runnable() {
@Override
public void run() {
testSynchronized.minus2();
}
});
//启动线程
thread1.start();
thread2.start();
}
}
执行结果
Thread-0 - 4
Thread-1 - 4
Thread-1 - 3
Thread-0 - 3
Thread-0 - 2
Thread-1 - 2
Thread-0 - 1
Thread-1 - 1
Thread-0 - 0
Thread-1 - 0
可以看到两个线程是交替进行的,也就是说类锁和对象锁是不一样的锁,是互相独立的。