synchronized关键字在Java中用于线程同步
可用于
1.修饰代码块
2.修饰类
3.修饰方法
1.修饰代码块
(1)一个线程访问一个对象中的synchronized(this)同步代码块时,其他试图访问该代码块的线程将被阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。
示例:
package com.czlt.syncorenizedtest;
public class MyRunnerable implements Runnable {
private int count = 0;
@Override
public void run() {
synchronized (this) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount() {
return count;
}
}
测试类
package com.czlt.syncorenizedtest;
public class Test {
public static void main(String[] args) {
MyRunnerable mRunnerable = new MyRunnerable();
Thread t1 = new Thread(mRunnerable, "Thread - A");
Thread t2 = new Thread(mRunnerable, "Thread - B");
t1.start();
t2.start();
}
}
结果:
Thread - A:0
Thread - A:1
Thread - A:2
Thread - A:3
Thread - A:4
Thread - B:5
Thread - B:6
Thread - B:7
Thread - B:8
Thread - B:9
(2)修饰代码块时,synchronized锁定的是对象
我们把测试类调整一下
package com.czlt.syncorenizedtest;
public class Test {
public static void main(String[] args) {
// MyRunnerable mRunnerable = new MyRunnerable();
Thread t1 = new Thread(new MyRunnerable(), "Thread - A");
Thread t2 = new Thread(new MyRunnerable(), "Thread - B");
t1.start();
t2.start();
}
}
结果:
Thread - A:0
Thread - B:0
Thread - B:1
Thread - A:1
Thread - A:2
Thread - B:2
Thread - A:3
Thread - B:3
Thread - B:4
Thread - A:4
由此可见,两个线程同时执行了同步代码块。
原因: 同步代码块实际锁定的是对象,而测试类中创建线程用的是两个不同的对象,因此锁定的对象不同,两个线程可同时执行。
(3) synchronized修饰代码块时,可以指定给某个对象加锁
用法:修改(1)中的代码
package com.czlt.syncorenizedtest;
public class MyRunnerable implements Runnable {
private int count = 0;
Object obj1 = new Object();
@Override
public void run() {
synchronized (obj1) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount() {
return count;
}
}
结果与(1)相同:
Thread - A:1
Thread - A:2
Thread - A:3
Thread - A:4
Thread - B:5
Thread - B:6
Thread - B:7
Thread - B:8
Thread - B:9
(4)synchronized同步代码块,指定给某个对象(假设该对象为obj1)加锁时,其他线程可访问 非synchronized修饰的代码 和 synchronized修饰的,但加锁对象非obj1的代码。
其他线程访问非synchronized修饰的代码就不给出示例了,下面给出加锁对象非obj1的代码。
package com.czlt.syncorenizedtest;
public class MyRunnerable implements Runnable {
private int count = 0;
Object obj1 = new Object();
Object obj2 = new Object();
@Override
public void run() {
if(Thread.currentThread().getName().equals("Thread - A")){
synchronized (obj1) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} else if(Thread.currentThread().getName().equals("Thread - B")){
synchronized (obj2) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public int getCount() {
return count;
}
}
测试类:
package com.czlt.syncorenizedtest;
public class Test {
public static void main(String[] args) {
MyRunnerable mRunnerable = new MyRunnerable();
Thread t1 = new Thread(mRunnerable, "Thread - A");
Thread t2 = new Thread(mRunnerable, "Thread - B");
t1.start();
t2.start();
}
}
结果:
Thread - A:0
Thread - B:1
Thread - B:2
Thread - A:3
Thread - A:4
Thread - B:5
Thread - A:6
Thread - B:7
Thread - A:9
Thread - B:8
2. 修饰类
synchronized作用于一个类T时,是给这个类T加锁,T的所有对象用的是同一把锁。
对比1中(2)的代码,测试类相同,将synchronized修饰对象改为修饰类:
package com.czlt.syncorenizedtest;
public class MyRunnerable implements Runnable {
private int count = 0;
@Override
public void run() {
synchronized (MyRunnerable.class) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public int getCount() {
return count;
}
}
测试类:
public static void main(String[] args) {
// MyRunnerable mRunnerable = new MyRunnerable();
Thread t1 = new Thread(new MyRunnerable(), "Thread - A");
Thread t2 = new Thread(new MyRunnerable(), "Thread - B");
t1.start();
t2.start();
}
结果:
Thread - A:0
Thread - A:1
Thread - A:2
Thread - A:3
Thread - A:4
Thread - B:0
Thread - B:1
Thread - B:2
Thread - B:3
Thread - B:4
可见,修饰类的时候,虽然创建线程使用的是不同的对象,但仍然可以实现线程同步。
3. 修饰方法
(1)修饰非静态方法时,效果等同于用synchronized(this)修饰整个方法中的代码块
public synchronized void method() {
}
等同于
public void method(){
synchronized (this) {
}
}
(2)修饰静态方法时,效果等同于用synchronized(类名.class)修饰整个方法中的代码块
public static synchronized void method() {
}
等同于
public static void method(){
synchronized (MyRunnerable.class) {
}
}
(3)注意点:
① synchronized关键字不能继承。
如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的
②构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。
不可写成
public synchronized MyRunnerable(){
}
但可以写成
public MyRunnerable(){
synchronized (this) {
}
}
③不能修饰接口中的方法
接口中,不可写成
public synchronized abstract void method1();