Android多线程-----并发和同步（synchronized）
一、锁
对象的内置锁和对象的状态之间是没有内在的关联的，虽然大多数类都将内置锁用做一种有效的加锁机制，但对象的域并不一定通过内置锁来保护。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。之所以每个对象都有一个内置锁，是为了免去显式地创建锁对象。
所以synchronized只是一个内置锁的加锁机制，当某个方法加上synchronized关键字后，就表明要获得该内置锁才能执行，并不能阻止其他线程访问不需要获得该内置锁的方法。
java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去，这对高并发的系统是致命的。
java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
1. 普通同步方法，锁是当前实例对象
2. 静态同步方法，锁是当前类的class对象
3. 同步方法块，锁是括号里面的对象
下面讲解
synchronized修饰方法，
synchronized修饰静态方法，
synchronized(this)，
synchronized(类)，
synchronized(变量)之间的区别
二、修饰方法和代码块
修饰方法是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。
public synchronized void method()
{
// todo
}
public void method()
{
synchronized(this) {
// todo
}
}
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
在子类方法中加上synchronized关键字
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}注意：
- 在定义接口方法时不能使用synchronized关键字。
- 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
(一)对象锁的synchronized修饰方法和代码块
public class TestSynchronized {
public void test1() {
synchronized (this) {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public synchronized void test2() {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final TestSynchronized myt2 = new TestSynchronized();
Thread test1 = new Thread(new Runnable() {
public void run() {
myt2.test1();
}
}, "test1");
Thread test2 = new Thread(new Runnable() {
public void run() {
myt2.test2();
}
}, "test2");
test1.start();
test2.start();
}
}
test2 : 4
test2 : 3
test2 : 2
test2 : 1
test2 : 0
test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0上述的代码，第一个方法时用了同步代码块的方式进行同步，传入的对象实例是this，表明是当前对象，当然，如果需要同步其他对象实例，也可传入其他对象的实例；第二个方法是修饰方法的方式进行同步。因为第一个同步代码块传入的this，所以两个同步代码所需要获得的对象锁都是同一个对象锁 ; main方法时分别开启两个线程，分别调用test1和test2方法，那么两个线程都需要获得该对象锁，另一个线程必须等待。上面也给出了运行的结果可以看到：直到test2线程执行完毕，释放掉锁，test1线程才开始执行。
如果我们把test2方法的synchronized关键字去掉，执行结果会如何呢？
test1 : 4
test2 : 4
test2 : 3
test1 : 3
test1 : 2
test2 : 2
test2 : 1
test1 : 1
test2 : 0
test1 : 0
上面是执行结果，我们可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）
（二）类锁的修饰（静态）方法和代码块
public class TestSynchronized {
public synchronized void test1() {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static synchronized void test2() {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final TestSynchronized myt2 = new TestSynchronized();
Thread test1 = new Thread(new Runnable() {
public void run() {
myt2.test1();
}
}, "test1");
Thread test2 = new Thread(new Runnable() {
public void run() {
TestSynchronized.test2();
}
}, "test2");
test1.start();
test2.start();
}
}
test1 :4
test2 :4
test1 :3
test2 :3
test2 :2
test1 :2
test2 :1
test1 :1
test1 :0
test2 :0上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。
三、对比
public class ThreadTest {
public static final String Lock = "lock";
public final Object obj = new Object();
synchronized void test1() throws InterruptedException {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test1=" + i);
}
}
synchronized static void test2() throws InterruptedException {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test2=" + i);
}
}
void test3() throws InterruptedException {
synchronized (this) {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test3=" + i);
}
}
}
void test4() throws InterruptedException {
synchronized (this.getClass()) {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test4=" + i);
}
}
}
void test5() throws InterruptedException {
synchronized (Lock) {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test5=" + i);
}
}
}
void test6() throws InterruptedException {
synchronized (obj) {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test6=" + i);
}
}
}
void test7() throws InterruptedException {
synchronized (ThreadTest.Lock) {
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("test7=" + i);
}
}
}
}一、同一个对象的同一个同步方法是同步的
二、同一个对象的synchronized方法和synchronized（this）块是同步的
方法test1和test3同步
这两个方法的锁都是加在当前对象上
三、类的static方法和synchronized（该类）块是同步的
方法test2和test4同步
这两个方法的锁都是加在ThreadTest类上面，方法test4的synchronized (this.getClass())块换成synchronized (ThreadTest.class)，结果是一样的，但是如果换成比如synchronized (String.class)就不能同步了
因为锁是加在类上面，所以不仅相同类的这两种方法是同步的，同一个类的不同对象之间的这两种方法也是同步的
四、第二点的两种方法和第三点的两种方法不同步
test1和test2不同步，test1和test4不同步
test3和test2不同步，test3和test4不同步
五、synchronized（变量）跟前面四种都不同步
因为锁加的目标不一样，既不是当前类也不是当前对象。
synchronized (obj)和synchronized (this)的用法基本一致，对当前对象加锁。
而synchronized (Lock)除了当前对象以外，本类的其他新建对象也会同步加锁，甚至于其他类如果调用的synchronized (ThreadTest.Lock)也会同步。
六、ThreadTest2的test7方法跟ThreadTest的test5方法是同步的；