JAVA-Android- 多线程实现方式及并发与同步
使用详解：线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。
2、块同步。同步块是通过锁定一个指定的对象，来对块中的代码进行同步；同步方法和同步块之间的相互制约只限于同一个对象之间，静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例没有关系。如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。
3、使用方法同步保护共享数据。示例：
public class ThreadTest implements Runnable{
public synchronized void run(){for(int i=0;i<10;i++) {System.out.print(" " + i);}}
public static void main(String[] args) {Runnable r1 = new ThreadTest();Runnable r2 = new ThreadTest();Thread t1 = new Thread(r1);Thread t2 = new Thread(r2);t1.start();t2.start();}}
示例详解：代码中可见，run()被加上了 synchronized?关键字，但保护的并不是共享数据。因为程序中两个线程对象 t1、t2 其实是另外两个线程对象 r1、r2 的线程，这个听起来绕，但是一眼你就能看明白；因为不同的线程对象的数据是不同的，即 r1,r2?有各自的 run()方法，所以输出结果就无法预知。这时使用 synchronized 关键字可以让某个时刻只有一个线程可以访问该对象 synchronized 数据。每个对象都有一个“锁标志”，当这个对象的一个线程访问这个对象的某个 synchronized?数据时，这个对象的所有被 synchronized?修饰的数据将被上锁（因为“锁标志”被当前线程拿走了），只有当前线程访问完它要访问的 synchronized?数据时，当前线程才会释放“锁标志”，这样同一个对象的其它线程才有机会访问 synchronized?数据。
接下来，我们把 r2 给注释掉， 即只保留一个 r 对象。如下：
public class ThreadTest implements Runnable{
public synchronized void run(){for(int i=0;i<10;i++){System.out.print(" " + i);}}
public static void main(String[] args){Runnable r = new ThreadTest();Thread t1 = new Thread(r);Thread t2 = new Thread(r);t1.start();t2.start();}}
示例详解：如果你运行 1000?次这个程序，它的输出结果也一定每次都是：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的 synchronized?保护的
是共享数据。t1,t2?是同一个对象（r）的两个线程，当其中的一个线程（例如：t1）开始执行 run()方法时，由于 run()受 synchronized 保护，所以同一个对象的其他线程（t2）无法访问 synchronized?方法（run?方法）。只有当 t1 执行完后 t2?才有机会执行。
4、使用块同步，示例：
public class ThreadTest implements Runnable{public void run(){synchronized(this){ //与上面示例不同于关键字使用 for(int i=0;i<10;i++){System.out.print(" " + i);}}}public static void main(String[] args){Runnable r = new ThreadTest();Thread t1 = new Thread(r);Thread t2 = new Thread(r);t1.start();t2.start();}}
示例详解：这个与上面示例的运行结果也一样的。这里是把保护范围缩到最小，this?代表 ‘这个对象’ ? 。没有必要把整个 run()保护起来，run()中的代码只有一个 for 循环，所以只要保护 for?循环就可以了。
最后，再看一个示例：
public class ThreadTest implements Runnable{
public void run(){for(int k=0;k<5;k++){System.out.println(Thread.currentThread().getName()+ " : for loop : " + k);}
synchronized(this){for(int k=0;k<5;k++) {System.out.println(Thread.currentThread().getName()+ " : synchronized for loop : " + k);}} }
public static void main(String[] args){Runnable r = new ThreadTest();Thread t1 = new Thread(r,"t1_name");Thread t2 = new Thread(r,"t2_name");t1.start();t2.start();} }
//运行结果：t1_name : for loop : 0t1_name : for loop : 1t1_name : for loop : 2t2_name : for loop : 0t1_name : for loop : 3t2_name : for loop : 1t1_name : for loop : 4t2_name : for loop : 2t1_name : synchronized for loop : 0t2_name : for loop : 3t1_name : synchronized for loop : 1t2_name : for loop : 4t1_name : synchronized for loop : 2t1_name : synchronized for loop : 3t1_name : synchronized for loop : 4t2_name : synchronized for loop : 0t2_name : synchronized for loop : 1t2_name : synchronized for loop : 2t2_name : synchronized for loop : 3t2_name : synchronized for loop : 4
示例详解：第一个 for?循环没有受 synchronized?保护。对于第一个 for?循环，t1,t2?可以同时访问。运行结果表明 t1?执行到了 k=2?时，t2?开始执行了。t1?首先执行完了第一个 for?循环，此时 t2 还没有执行完第一个 for?循环（t2?刚执行到 k=2）。t1?开始执行第二个 for?循环，当 t1 的第二个 for?循环执行到 k=1?时，t2?的第一个 for?循环执行完了。t2?想开始执行第二个 for?循环，但由于 t1?首先执行了第二个 for?循环，这个对象的锁标志自然在 t1?手中（synchronized?方法的执行权也就落到了 t1?手中），在 t1?没执行完第二个 for?循环的时候，它是不会释放锁标志的。所以 t2?必须等到 t1?执行完第二个 for?循环后，它才可以执行第二个 for?循环。
###Volatile?同步
a.volatile 关键字为域变量的访问提供了一种免锁机制 b.使用 volatile 修饰域相当于告诉虚拟机该域可能会被其他线程更新 c.因此每次使用该域就要重新计算，而不是使用寄存器中的值?d.volatile 不会提供任何原子操作，它也不能用来修饰 final 类型的变量?例如：?在上面的例子当中，只需在 account 前面加上 volatile 修饰，即可实现线程同步。?代码实例：?
//只给出要修改的代码，其余代码与上同 class Bank {//需要同步的变量加上 volatileprivate volatile int account = 100;
public int getAccount() {return account;}//这里不再需要 synchronizedpublic void save(int money) {account += money;}｝
注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。?用 final 域，有锁保护的域和 volatile 域可以避免非同步的问题。?
###重入锁同步
在?JavaSE5.0 中?新增了一个 java.util.concurrent 包来支持同步。?ReentrantLock 类是可重入、互斥、实现了 Lock 接口的锁，它与使用 synchronized 方法和快具有相同的基本行为和语义，并且扩展了其能力。?ReenreantLock 类的常用方法有：
ReentrantLock() : 创建一个 ReentrantLock 实例 lock() : 获得锁 unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 例如：?
class Bank {private int account = 100;//需要声明这个锁 private Lock lock = new ReentrantLock();public int getAccount() {return account;}//这里不再需要 synchronizedpublic void save(int money) {lock.lock();try{account += money;}finally{lock.unlock();}}｝
注：关于 Lock 对象和 synchronized 关键字的选择：?a.最好两个都不用，使用一种 java.util.concurrent 包提供的机制，能够帮助用户处理所有与锁相关的代码。?b.如果 synchronized 关键字能满足用户的需求，就用 synchronized，因为它能简化代码?c.如果需要更高级的功能，就用 ReentrantLock 类，此时要注意及时释放锁，否则会出现死锁，通常在 finally 代码释放锁?
###局部变量同步如果使用 ThreadLocal 管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。 ThreadLocal 类的常用方法：
ThreadLocal() : 创建一个线程本地变量 get() : 返回此线程局部变量的当前线程副本中的值 initialValue() : 返回此线程局部变量的当前线程的"初始值"set(T value) : 将此线程局部变量的当前线程副本中的值设置为 value
例如：
public class Bank{//使用 ThreadLocal 类管理共享变量 accountprivate static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){@Overrideprotected Integer initialValue(){return 100;}};public void save(int money){account.set(account.get()+money);}public int getAccount(){return account.get();}}
注：ThreadLocal 与同步机制?a.ThreadLocal 与同步机制都是为了解决多线程中相同变量的访问冲突问题。b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式
###阻塞队列同步前面同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。 使用 javaSE5.0 版本中新增的 java.util.concurrent 包将有助于简化开发。 本小节主要是使用 LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的 blocking queue。 队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法?LinkedBlockingQueue() : 创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue put(E e) : 在队尾添加一个元素，如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素，如果队列空则阻塞代码实例：?实现商家生产商品和买卖商品的同步
注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：
add()方法会抛出异常
offer()方法返回 false
put()方法会阻塞
###原子变量同步需要使用线程同步的根本原因在于对普通变量的操作不是原子的。
那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。在 java 的 util.concurrent.atomic 包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中 AtomicInteger?表可以用原子方式更新 int 的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换 Integer；可扩展 Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。
AtomicInteger 类常用方法：
AtomicInteger(int initialValue) : 创建具有给定初始值的新的
AtomicIntegeraddAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值
代码实例：
class Bank {private AtomicInteger account = new AtomicInteger(100);public AtomicInteger getAccount() {return account;}public void save(int money) {account.addAndGet(money);}}
补充--原子操作主要有：
对于引用变量和大多数原始变量(long 和 double 除外)的读写操作；
对于所有使用 volatile 修饰的变量(包括 long 和 double)的读写操作。
另外，可以使用线程池进行管理及优化。
【附】相关架构视频资料
资料领取
关注+点赞+加群：185873940 免费获取！
点击链接加入群聊【Android IOC 架构设计】：https://jq.qq.com/?_wv=1027&k=5tIZkaU
领取获取往期 Android 高级架构资料、源码、笔记、视频。高级 UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter 全方面的 Android 进阶实践技术
评论