Android（java）同步方法synchronized

synchronized 是java语言关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

本文直接以代码的形式来展示synchronized 关键字的使用：

【1】synchronized Demo1：

[html] view plain copy

packagecom.andyidea.demo;
/**
*当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，
*一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码
*块以后才能执行该代码块。
*@authorAndy.Chen
*
*/
publicclassThread01implementsRunnable{
@Override
publicvoidrun(){
synchronized(this){
for(inti=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"synchronizedloop"+i);
}
}
}
publicstaticvoidmain(String[]args){
Thread01t01=newThread01();
System.out.println("synchronized关键字使用\n"
+"--------------------------");
Threadta=newThread(t01,"A");
Threadtb=newThread(t01,"B");
ta.start();
tb.start();
}
}

运行结果如下：

[html] view plain copy

synchronized关键字使用
--------------------------
Bsynchronizedloop0
Bsynchronizedloop1
Bsynchronizedloop2
Asynchronizedloop0
Asynchronizedloop1
Asynchronizedloop2

【2】synchronized Demo2：

[html] view plain copy

packagecom.andyidea.demo;
/**
*当一个线程访问object的一个synchronized(this)同步代码块时，
*另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
*@authorAndy.Chen
*
*/
publicclassThread02{
publicvoidmethod01(){
synchronized(this){
inti=0;
while(i++<3){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
publicvoidmethod02(){
//第1种方式:当一个线程访问object的一个synchronized(this)同步代码块时，
//另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
//intj=0;
//while(j++<3){
//System.out.println(Thread.currentThread().getName()+":"+j);
//try{
//Thread.sleep(1000);
//}catch(InterruptedExceptione){
//e.printStackTrace();
//}
//}
//第2种方式:当一个线程访问object的一个synchronized(this)同步代码块时，
//其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
synchronized(this){
intj=0;
while(j++<3){
System.out.println(Thread.currentThread().getName()+":"+j);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
/**
*当一个线程访问object的一个synchronized(this)同步代码块时，
*它就获得了这个object的对象锁。
*结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
*/
publicsynchronizedvoidmethod3(){
intk=0;
while(k++<3){
System.out.println(Thread.currentThread().getName()+":"+k);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
publicstaticvoidmain(String[]args){
finalThread02t02=newThread02();
System.out.println("synchronized关键字使用\n"
+"--------------------------");
Threadt02A=newThread(newRunnable(){
@Override
publicvoidrun(){
t02.method01();
}
},"A");
Threadt02B=newThread(newRunnable(){
@Override
publicvoidrun(){
t02.method02();
}
},"B");
Threadt02C=newThread(newRunnable(){
@Override
publicvoidrun(){
t02.method3();
}
},"C");
t02A.start();
t02B.start();
t02C.start();
}
}

运行结果如下：

[html] view plain copy

synchronized关键字使用
--------------------------
B:1
B:2
B:3
C:1
C:2
C:3
A:1
A:2
A:3

【3】synchronized Demo3：

[html] view plain copy

packagecom.andyidea.demo;
/**
*synchronized对象锁
*@authorAndy.Chen
*
*/
publicclassThread03{
classInnerObject{
/**
*内部类方法1
*/
privatevoidinnerMethod01(){
inti=0;
while(i++<3){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
/**
*内部类方法2
*/
privatevoidinnerMethod02(){
intj=0;
while(j++<3){
System.out.println(Thread.currentThread().getName()+":"+j);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
/**
*外部类方法1
*@paraminnerObj
*/
privatevoidouterMethod01(InnerObjectinnerObj){
synchronized(innerObj){
innerObj.innerMethod01();
}
}
/**
*外部类方法2
*@paraminnerObj
*/
privatevoidouterMethod02(InnerObjectinnerObj){
innerObj.innerMethod02();
}
publicstaticvoidmain(String[]args){
finalThread03t03=newThread03();
finalInnerObjectinnerObj=t03.newInnerObject();
System.out.println("synchronized关键字使用\n"
+"--------------------------");
Threadt03A=newThread(newRunnable(){
@Override
publicvoidrun(){
t03.outerMethod01(innerObj);
}
},"A");
Threadt03B=newThread(newRunnable(){
@Override
publicvoidrun(){
t03.outerMethod02(innerObj);
}
},"B");
t03A.start();
t03B.start();
}
}

运行结果如下：

[html] view plain copy

synchronized关键字使用
--------------------------
A:1
B:1
B:2
A:2
B:3
A:3

总结：

1. synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

2.synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

对synchronized(this)的一些理解
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

更多相关文章

随机推荐