[移动开发]Android synchronized

1.synchronized

synchronized用于多线程访问，并且被修饰的部分不能同时被执行，是代码同步的一种方式。

①使用synchronized修饰方法

当多个线程同时访问被synchronized修饰的方法时，有且仅有一个线程可以被访问，当一个线程在访问时，其它线程只能等待。当一个线程访问完毕后，下一个线程才可以访问。

原理：当方法被synchronized修饰后，如果想要执行该方法就必须获得相应的锁。每个类有且仅有一个锁(针对静态方法)，每个类的实例也是有且仅有一个锁。当多个线程在同时访问同一个方法时，执行该方法就必须获得相应的锁，同时锁只有一个，所以只能有一个线程可以获得锁，其它的线程必须等待该线程释放锁后才能获取到该锁。

进阶说明：由于每个类只有一个锁，所以当一个类中有多个方法被synchronized修饰时，在同一时间内只能有一个方法可以获得锁，所以只有一个被synchronized修饰的方法可以执行。

举例说明：

public void showDo(String msg){

? ? for(int i=0;i<1000000;i++){

? ? ? ? if (i%100000==0){

? ? ? ? ? ? System.out.println("打印结果" + msg + i/100000);

? ? ? ? }

? ? }

}

//使用

new Thread(){

? ? @Override

? ? public void run() {

? ? ? ? super.run();

? ? ? ? showDo("线程一");

? ? }

}.start();

new Thread(){

? ? @Override

? ? public void run() {

? ? ? ? super.run();

? ? ? ?showDo("线程二");

? ? }

}.start();

未加synchronized修饰方法，可以看到执行顺序是打乱的，无序的。

加了synchronized后：

public synchronized void showDo(String msg){

? ? for(int i=0;i<1000000;i++){

? ? ? ? if (i%100000==0){

? ? ? ? ? ? ?System.out.println("打印结果" + msg + i/100000);

? ? ? ? }

? ? }

}

这也就是同步方法，这时synchronized锁定的是哪个对象呢？他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了synchronized关键字的方法。

上边的示例代码等同于如下代码：

public void method()? {? ? ??

? ? synchronized (this) {? ? ??

? ? ? ?//…..? ? ??

? ? }? ? ??

}? ? ?

this指的是什么呢？他指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才能够调用P1的同步方法，而对P2而言，P1这个锁和他毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱。

②使用synchronized修饰代码块

public void method(SomeObject so) {? ? ??

? ? synchronized(so)? {? ? ??

? ? ? ?//…..? ? ??

? ? }? ? ??

}? ? ?

这时，锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码。当有一个明确的对象作为锁时，就能够这样写，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（得是个对象）来充当锁：

class Foo implements Runnable?{? ? ??

? ?private byte[] lock = new byte[0]; // 特别的instance变量? ? ??

??Public void method()?{? ? ??

? ? ? ?synchronized(lock) { //… }? ? ??

? }? ? ??

? //…..? ? ??

}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

?举例说明：

private static String s1 = "";

private static String s2 = "aa";

public void showDo(String msg) {

? ? synchronized (s1){

? ? ? ? for (int i = 0; i < 10; i++) {

? ? ? ? ? ? if (i % 2?== 0) {

? ? ? ? ? ? ? ? System.out.println("打印结果" + msg + i / 2);

? ? ? ? ? ? }

? ? ? ? }

? ? }

}

public void showDo1(String msg) {

? ? synchronized (s2){

? ? ? ? for (int i = 0; i < 10; i++) {

? ? ? ? ? ? if (i % 12?== 0) {

? ? ? ? ? ? ? ? System.out.println("打印" + msg + i / 2);

? ? ? ? ? ? }

? ? ? ? }

? ? }

}

//调用

new Thread() {

? ? @Override

? ? public void run() {

? ? ? ? super.run();

? ? ? ? showDo1("线程一");

? ?}

}.start();

new Thread() {

? ? @Override

? ? public void run() {

? ? ? ? super.run();

? ? ? ? showDo("线程二");

? ? ? ? showDo1("线程二");

? ? }

}.start();

由上可得，多个同步锁，只有竞争同一个同步锁才会需要等待，不是竞争同一个锁的代码块互不影响。

③

2.

synchronized不能修饰构造函数

定义接口方法时不能使用synchronized

synchronized(this)锁的是当前对象，当前有几个对象，this就有多少份

synchronized(XX.class)这个与当前对象无关，只要锁是XX.class的都会被同步

如果同一个类中有多个方法使用了同步锁synchronized(this)或者多个方法被synchronized修饰，则多个线程访问该类中同步方法时，每次只能访问一个，其它的被阻塞。如:

public synchronized void A(){

? ? ......

}

public synchronized void B(){

? ? ......

}

有两个线程分别访问同一个对象T的A方法和B方法，则同时只能有一个方法被其中一个线程访问，另一个线程处于阻塞状态，因为方法A和B持有同一个对象锁，synchronized(this)也是类似的情况。

同一个类中有多个方法使用了同步锁synchronized修饰，且这些类是静态的，因为静态方法是属于类的，而不是属于某个对象的，所以它与synchronized(XX.class)类似。

public synchronized static void method() {

? ? // todo

}

每个对象只有一个锁(lock)与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

?

更有一些技巧能够让我们对共享资源的同步访问更加安全：?
①定义private 的instance变量+他的 get方法，而不要定义public/protected的instance变量。假如将变量定义为public，对象在外界能够绕过同步方法的控制而直接取得他，并改变他。这也是JavaBean的标准实现方式之一。
②假如instance变量是个对象，如数组或ArrayList，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。

?