---恢复内容开始---
多线程
在开发中,遇到耗时的操作,我们需要把耗时的逻辑放入子线程中执行,防止Android页面卡顿。
为什么使用同步锁?
前段时间我做了一个多任务下载的功能,每一个任务开启一个线程,同时创建了一个线程池,存放所有的任务线程,并且可以设定可支持同时下载2个任务。当下载完成文件后,
需要解析文件的操作,并把解析的数据插入数据库。现在就有一种情况是如果两个任务同时执行完成,同时解析文件,获取数据后,同时插入数据库,由于插入的表比较多,
而且数据库的DB使用的是单例,这样就会出现插入错乱的bug。我们采用synchronized声明该方法为同步方法,如果一个方法正在执行,别的方法调用,则处于等待状态。
当这个方法执行完成后,可以调用解锁方法,wait():释放占有的对象锁，线程进入等待池。
synchronized使用：
因为很方便,比如需要对一个方法进行同步,那么只需在方法的签名添加一个synchronized关键字。
1. // 未同步的方法
public void test() {}
2. // 同步的方法
pubilc synchronized void test() {}
3. // synchronized 也可以用在一个代码块上
public void test() {
synchronized(obj) {
System.out.println("===");
}
}public void test() {
...
synchronized(this) {
// todo your code
}
...
}
此时，其效果等同于
public synchronized void test() {
// todo your code
}
使用synchronized代码块，可以只对需要同步的代码进行同步，这样可以大大的提高效率。
wait() 与notify()/notifyAll()使用:
这三个方法都是Object的方法，并不是线程的方法！
wait() : 释放占有的对象锁，线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。而sleep()不同的是,线程调用此方法后,会休眠一段时间,休眠期间,会暂时释放cpu,但并不释放对象锁。也就是说,在休眠期间,其他线程依然无法进入此代码内部。休眠结束,线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会！
notify() : 该方法会唤醒因为调用对象的wait()而等待的线程,其实就是对对象锁的唤醒,从而使得wait()的线程可以有机会获取对象锁。调用notify()后,并不会立即释放锁,
线程A： public class Produce implements Runnable { @Override public void run() { // TODO Auto-generated method stub int count = 10; while(count > 0) { synchronized (Test. obj) { //System.out.print("count = " + count); System. out.print( "A"); count --; Test. obj.notify(); try { Test. obj.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }
线程B： public class Consumer implements Runnable { @Override public synchronized void run() { // TODO Auto-generated method stub int count = 10; while(count > 0) { synchronized (Test. obj) { System. out.print( "B"); count --; Test. obj.notify(); // 主动释放对象锁 try { Test. obj.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }
测试类如下：
public class Test {
public static final Object obj = new Object();
public static void main(String[] args) {
new Thread( new Produce()).start();
new Thread( new Consumer()).start();
}
}
这里使用static obj作为锁的对象,当线程Produce启动时（假如Produce首先获得锁，则Consumer会等待）,打印“A”后,会先主动释放锁,然后阻塞自己。Consumer获得对象锁,打印“B”,然后释放锁,阻塞自己,那么Produce又会获得锁,然后...一直循环下去,直到count = 0.这样,使用Synchronized和wait()以及notify()就可以达到线程同步的目的。
除了wait()和notify()协作完成线程同步之外，使用Lock也可以完成同样的目的。
ReentrantLock:
ReentrantLock 与synchronized有相同的并发性和内存语义,还包含了中断锁等候和定时锁等候,意味着线程A如果先获得了对象obj的锁,那么线程B可以在等待指定时间内依然无法获取锁,那么就会自动放弃该锁。
但是由于synchronized是在JVM层面实现的,因此系统可以监控锁的释放与否,而ReentrantLock使用代码实现的,系统无法自动释放锁,需要在代码中finally子句中显式释放锁lock.unlock();
这样的例子，使用lock 如何实现呢？
public class Producer implements Runnable{ private Lock lock; public Producer(Lock lock) { this. lock = lock; } @Override public void run() { // TODO Auto-generated method stub int count = 10; while (count > 0) { try { lock.lock(); count --; System. out.print( "A"); } finally { lock.unlock(); try { Thread. sleep(90L); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }
public class Consumer implements Runnable { private Lock lock; public Consumer(Lock lock) { this. lock = lock; } @Override public void run() { // TODO Auto-generated method stub int count = 10; while( count > 0 ) { try { lock.lock(); count --; System. out.print( "B"); } finally { lock.unlock(); //主动释放锁 try { Thread. sleep(91L); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }
调用代码：
public class Test {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Consumer consumer = new Consumer(lock);
Producer producer = new Producer(lock);
new Thread(consumer).start();
new Thread( producer).start();
}
}
---恢复内容结束---