synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:
1. 修饰一个代码块,被修饰的代码块称为同步语句块,作用的对象是调用这个代码块的对象,其作用的范围有以下两种情况;
- synchronized(SynchronizedTest .class)为类锁,则无论是都相同对象调用都为同步阻塞.
- synchronized(this)为对象锁,不通对象调用时不会阻塞,相同对象调用时为同步阻塞。
package guan;
public class SynchronizedTest {
int num;
public static void main(String[] args) {
final SynchronizedTest demo1 = new SynchronizedTest();
final SynchronizedTest demo2 = new SynchronizedTest();
// Thread t1 = new Thread(new Runnable() {
//
// @Override
// public void run() {
// demo1.methodA();
// }
// });
// t1.start();
//
// Thread t2 = new Thread(new Runnable() {
// @Override
// public void run() {
// demo1.methodA();
// }
// });
// t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
demo1.methodB();
}
});
t3.start();
Thread t4 = new Thread(new Runnable() {
@Override
public void run() {
demo2.methodB();
}
});
t4.start();
}
public void methodA(){
synchronized(SynchronizedTest.class) {
System.out.println("start running methodA");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end running methodA");
}
}
public void methodB(){
synchronized(this) {
System.out.println("start running methodB");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end running methodB");
}
}
}
2. 修饰一个普通方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象,不同对象调用不会阻塞,同一对象调用则会阻塞,此时为对象锁;
package guan;
public class SynchronizedTest {
int num;
public static void main(String[] args) {
final SynchronizedTest demo1 = new SynchronizedTest();
final SynchronizedTest demo2 = new SynchronizedTest();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.method("a");
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo2.method("b");
}
});
t2.start();
}
public synchronized void method(String arg) {
try {
if("a".equals(arg)){
num = 2;
System.out.println("start running a");
Thread.sleep(1000);
}else{
num = 3;
System.out.println("start running b");
}
System.out.println("demo = "+ arg + ";num ="+ num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
程序输出:
start running a
start running b
demo = b;num =200
demo = a;num =100
由结果得出,两个不同的对象demo1和demo2的method()方法执行并没有阻塞,因为这里synchronized是分别持有两个对象的锁,如果两个线程为同一对象的话还是会阻塞。如果要想m1,m2两个对象竞争同一个锁,则需要在method()上加上static修饰。如下:
3. 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象,无论是是否为同一对象都会阻塞,此时为类锁;
package guan;
public class SynchronizedTest {
static int num;
public static void main(String[] args) {
final SynchronizedTest demo1 = new SynchronizedTest();
final SynchronizedTest demo2 = new SynchronizedTest();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.method01("a");
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo2.method01("b");
}
});
t2.start();
}
public static synchronized void method01(String arg) {
try {
if("a".equals(arg)){
num = 2;
System.out.println("start running a");
Thread.sleep(1000);
}else{
num = 3;
System.out.println("start running b");
}
System.out.println("demo = "+ arg + ";num ="+ num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出结果:
start running a
demo = a;num =2
start running b
demo = b;num =3
4、总结:
- 修饰普通方法,相同对象阻塞,不同对象不阻塞。
- 修饰静态方法,无论是否为同一对象,均为阻塞。
- 修饰代码块,如果为对象锁则相同对象阻塞,不同对象不阻塞。如果为类锁,无论是否为同一对象,均为阻塞。