Android synchronized用法

在网上看了不少介绍Java 多线程同步的文章，如下两篇文章行文清楚，算是帮我解了疑惑。原文链接如下：

《android-线程同步》：http://blog.csdn.net/winson_jason/article/details/8602446

《Java多线程同步Synchronized深入解析》：http://blog.csdn.net/rain_butterfly/article/details/8075511

同步这个词是从英文synchronize（使同时发生）翻译过来的，线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。
因此，
关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。
关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。
关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。

现代的编程语言的设计思路都是把同步锁加在代码段上。确切的说，是把同步锁加在“访问共享资源的代码段”上。这一点一定要记住，同步锁是加在代码段上的。

现在我们就来仔细分析“同步锁加在代码段上”的线程同步模型。
首先，我们已经解决了同步锁加在哪里的问题。我们已经确定，同步锁不是加在共享资源上，而是加在访问共享资源的代码段上。
其次，我们要解决的问题是，我们应该在代码段上加什么样的锁。这个问题是重点中的重点。这是我们尤其要注意的问题：访问同一份共享资源的不同代码段，应该加上同一个同步锁；如果加的是不同的同步锁，那么根本就起不到同步的作用，没有任何意义。
这就是说，同步锁本身也一定是多个线程之间的共享对象。

在 Java里面，同步锁的概念就是这样的。任何一个Object Reference都可以作为同步锁。我们可以把Object Reference理解为对象在内存分配系统中的内存地址。因此，要保证同步代码段之间使用的是同一个同步锁，我们就要保证这些同步代码段的 synchronized关键字使用的是同一个Object Reference，同一个内存地址。

每一个同步锁下面都挂了几个线程队列，包括就绪（Ready）队列，待召（Waiting）队列等。每个队列里面都可能有多个暂停运行的线程。
注 意，竞争同步锁失败的线程进入的是该同步锁的就绪（Ready）队列，而不是待召队列（Waiting Queue，也可以翻译为等待队列）。就绪队列里面的线程总是时刻准备着竞争同步锁，时刻准备着运行。而待召队列里面的线程则只能一直等待，直到等到某个信号的通知之后，才能够转移到就绪队列中，准备运行。
成功获取同步锁的线程，执行完同步代码段之后，会释放同步锁。该同步锁的就绪队列中的其他线程就继续下一轮同步锁的竞争。成功者就可以继续运行，失败者还是要乖乖地待在就绪队列中。
因此，线程同步是非常耗费资源的一种操作。我们要尽量控制线程同步的代码段范围。同步的代码段范围越小越好。

1. Synchronized 加在方法上， (同步方法，锁定类实例)

    public class Demo1 {


        public synchronized void m1() {
            //...............   

        }

        public void m2() {
            //............   

            synchronized (this) {
                //.........

            }
            //........     

        }
    }

这两种写法的效果是一样的，同步锁都是类的一个实例对象。

2. Synchronized 加在变量上， (同步块，锁定类实例)

    public class Demo2 {
        Object a = new Object();
        Object b = new Object();

        public void m1() {
            //............     

            synchronized (a) {
                //.........     
            }

            //........     
        }

        public void m2() {
            //............     

            synchronized (b) {
                //.........     
            }

            //........     
        }
    }

这种情况下，是实现代码块锁定，同步锁是 变量 a 或 b; (注意，a 、b 都是非static 的)如果有一个 类实例对象： demo = new Demo2()，另外有两个线程： thread1，thread2，都调用了demo 对象，那么，由于方法m1和方法m2使用的同步锁不同，所以在同一时间，如果 thread1调用了demo.m1()，则thread2在该时间内可以访问demo.m2();但不能访问 demo.m1() 的同步块， 因为a被 thread1锁定了。

3. Synchronized 锁定的是 类变量 ，即static 变量(可能是属性，可能是方法)(锁定类对象)

public class Demo3 {     
    static Object o = new Object();     
    
    public static synchronized void m1() {     
        //....     
    }     
    
    public static void m2() {     
        //...     
        synchronized (Demo3.class) {     
            //.....     
        }     
        //.....     
    }     
    
    public static void m3() {     
        //..........     
        try {     
            synchronized (Class.forName("Demo3")) {     
              //............     
            }     
        } catch (ClassNotFoundException ex) {     
        }     
        //.............     
    }     
    
    public static void m4() {     
        //............     
       synchronized(o){     
         //........     
       }     
        //..........     
    }     
}

以上4个方法中实现的效果都是一样的，其锁定的对象都是类Demo3，而不是类实例对象 ，即在多线程中，其共享的资源是属于类的，而不是属于类对象的。在这种情况下，如果thread1 访问了这4个方法中的任何一个， 在同一时间内其它的线程都不能访问 这4个方法。

---------------------------------------------------------------------------------------------------------------------------------------------

信号量
同步锁模型只是最简单的同步模型。同一时刻，只有一个线程能够运行同步代码。
有的时候，我们希望处理更加复杂的同步模型，比如生产者/消费者模型、读写同步模型等。这种情况下，同步锁模型就不够用了。我们需要一个新的模型。这就是我们要讲述的信号量模型。
信号量模型的工作方式如下：线程在运行的过程中，可以主动停下来，等待某个信号量的通知；这时候，该线程就进入到该信号量的待召（Waiting）队列当中；等到通知之后，再继续运行。
很多语言里面，同步锁都由专门的对象表示，对象名通常叫Monitor。
同样，在很多语言中，信号量通常也有专门的对象名来表示，比如，Mutex，Semphore。
信号量模型要比同步锁模型复杂许多。一些系统中，信号量甚至可以跨进程进行同步。另外一些信号量甚至还有计数功能，能够控制同时运行的线程数。
我们没有必要考虑那么复杂的模型。所有那些复杂的模型，都是最基本的模型衍生出来的。只要掌握了最基本的信号量模型——“等待/通知”模型，复杂模型也就迎刃而解了。
我们还是以Java语言为例。Java语言里面的同步锁和信号量概念都非常模糊，没有专门的对象名词来表示同步锁和信号量，只有两个同步锁相关的关键字——volatile和synchronized。
这种模糊虽然导致概念不清，但同时也避免了Monitor、Mutex、Semphore等名词带来的种种误解。我们不必执着于名词之争，可以专注于理解实际的运行原理。
在Java语言里面，任何一个Object Reference都可以作为同步锁。同样的道理，任何一个Object Reference也可以作为信号量。
Object对象的wait()方法就是等待通知，Object对象的notify()方法就是发出通知。
具体调用方法为
（1）等待某个信号量的通知
public static final Object signal = new Object();

… f1() {
synchronized(singal) { // 首先我们要获取这个信号量。这个信号量同时也是一个同步锁

// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.wait(); // 这里要放弃信号量。本线程要进入signal信号量的待召（Waiting）队列

// 可怜。辛辛苦苦争取到手的信号量，就这么被放弃了
// 等到通知之后，从待召（Waiting）队列转到就绪（Ready）队列里面
// 转到了就绪队列中，离CPU核心近了一步，就有机会继续执行下面的代码了。
// 仍然需要把signal同步锁竞争到手，才能够真正继续执行下面的代码。命苦啊。
…
}
}


需要注意的是，上述代码中的signal.wait()的意思。signal.wait()很容易导致误解。signal.wait()的意思并不是说，signal开始wait，而是说，运行这段代码的当前线程开始wait这个signal对象，即进入signal对象的待召（Waiting）队列。

（2）发出某个信号量的通知
… f2() {
synchronized(singal) { // 首先，我们同样要获取这个信号量。同时也是一个同步锁。

// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.notify(); // 这里，我们通知signal的待召队列中的某个线程。

// 如果某个线程等到了这个通知，那个线程就会转到就绪队列中
// 但是本线程仍然继续拥有signal这个同步锁，本线程仍然继续执行
// 嘿嘿，虽然本线程好心通知其他线程，
// 但是，本线程可没有那么高风亮节，放弃到手的同步锁
// 本线程继续执行下面的代码
…
}
}

需要注意的是，signal.notify()的意思。signal.notify()并不是通知signal这个对象本身。而是通知正在等待signal信号量的其他线程。

以上就是Object的wait()和notify()的基本用法。
实际上，wait()还可以定义等待时间，当线程在某信号量的待召队列中，等到足够长的时间，就会等无可等，无需再等，自己就从待召队列转移到就绪队列中了。
另外，还有一个notifyAll()方法，表示通知待召队列里面的所有线程。