Android开发，避免不了的就是线程，不管是访问网络、读取文件还是其他一些耗时的任务，都应该在子线程中处理。这样，也就避免不了线程同步问题。
- 线程同步有哪些办法？
遇到这个问题，我们一般使用的是synchronized进行同步，当然，有些同步也会通过lock去完成。如果是一些简单的同步，我们会使用关键字volatile去处理，也会使用原子变量AtomicXXX处理。
synchronized
对一个对象加锁，可以修饰一个方法或者代码块。
- 对一个代码块加锁，我们最常见的就是单例模式：
private static volatile Project sInstance;
private Project(){}
public static Project getInstance(){
if(sInstance == null){
synchronized (Project.class){
if(sInstance == null){
sInstance = new Project();
}
}
}
return sInstance;
}
- 对一个方法加锁，这个在一些同步方法中很常见
public synchronized void set(){
}
- 使用synchronized时，最主要的注意加锁对象。尤其是对方法加锁时，要注意静态方法和非静态方法的加锁对象是不一致的。
public synchronized void get(){
System.out.println("not static:"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
System.out.println("sleep stop:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized static void getS(){
System.out.println("static:"+Thread.currentThread().getName());
}
public static void main(String[] args){
final ThreadSync threadSync = new ThreadSync();
new Thread(new Runnable() {
@Override
public void run() {
threadSync.get();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
ThreadSync.getS();
threadSync.get();
}
}).start();
}
输出
通过输出可以看出：
1 先执行线程0，输出正常的日志，然后线程0休眠。注意sleep不会释放锁
2 在执行线程1，输出正常的日志。如果锁没有生效，应该输出的是get方法的第一句日志。但是因为锁的原因一直等到线程0休眠结束
- synchronized 加在静态方法时，锁的对象是当前的类对象，也就是class对象
- synchronized加载非静态方法时，锁的对象是当前的对象，所以new 不同的对象时锁也不一样
public synchronized static void getS(){
System.out.println("static:"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
System.out.println("sleep stop:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void get1(){
synchronized (ThreadSync.class){
System.out.println("class :"+Thread.currentThread().getName());
}
}
public static void main(String[] args){
final ThreadSync threadSync = new ThreadSync();
new Thread(new Runnable() {
@Override
public void run() {
ThreadSync.getS();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
threadSync.get1();
}
}).start();
}
image.png
1 可以看到，先执行的是线程0，输出第一句话，然后线程进入休眠
2 等到线程0休眠结束，开始执行线程1的方法，这两个方法都加在class对象上
Lock
java还提供了Lock对象进行加锁，不过这个Android开发中用的并不是很多。首先我们看看Lock如何加锁
private static Lock lock = new ReentrantLock();
public void get(){
lock.lock();
System.out.println("not static:"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
System.out.println("sleep stop:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
}
public static void getS(){
lock.lock();
System.out.println("static:"+Thread.currentThread().getName());
lock.unlock();
}
public static void main(String[] args){
final ThreadSync threadSync = new ThreadSync();
new Thread(new Runnable() {
@Override
public void run() {
threadSync.get();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
threadSync.getS();
}
}).start();
}
image.png
可以看到，一般通过lock()方法开始加锁，通过unlock方法释放锁。
注意，如果忘记调用unlock方法，那么锁一直释放不了！
那么除去这两个方法，还有哪些方法呢？
image.png
- tryLock
private static Lock lock = new ReentrantLock();
public void get(){
boolean isLock = lock.tryLock();
System.out.println("not static:"+isLock+":"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
System.out.println("sleep stop:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
}
public static void getS(){
boolean isLock = lock.tryLock();
if(isLock) {
System.out.println("static:" +isLock+":"+ Thread.currentThread().getName());
lock.unlock();
}else {
System.out.println("static:" + isLock + ":" + Thread.currentThread().getName());
}
}
image.png
可以看到，日志还是顺序输出了！
1 tryLock 含义也就是“试着获取锁”，如果没有获取到锁，那么返回false,如果获取到锁，那么返回true。
2 还有一个带时间的tryLock方法，就是在最大多长时间内，如果没有获取到锁，那么就放弃获取锁。
- lockInterruptibly
private static Lock lock = new ReentrantLock();
public void get() {
try {
lock.lockInterruptibly();
System.out.println("lock :"+ Thread.currentThread().getName());
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
final ThreadSync threadSync = new ThreadSync();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
threadSync.get();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
threadSync.get();
}
});
thread1.start();
thread2.start();
try {
Thread.sleep(100);
thread2.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
image.png
可以看出，线程0正常执行。线程1 在获取锁过程中，如果线程调用interrupt()，那么线程1就出现一个异常。
当我们替换为lock时，输出结果如下图：
image.png
可以看出：如果是lock获取锁，那么在获取锁的过程中中断线程不会有任何的反应。但是获取到锁之后，中断开始响应，所以线程停止休眠，抛出一个中断异常。
- newCondition
我们在使用synchronized时，很多情况会用到Object. wait，notify。而且这些方法必须放在synchronized代码块中。那么Lock有没有相应的功能呢，这个就是newCondition。
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
public void get() {
try {
lock.lock();
System.out.println("wait :"+ Thread.currentThread().getName());
condition.await();
System.out.println("lock :"+ Thread.currentThread().getName());
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
final ThreadSync threadSync = new ThreadSync();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
threadSync.get();
}
});
thread1.start();
try {
Thread.sleep(100);
lock.lock();
condition.signal();
System.out.println("signal :"+ Thread.currentThread().getName());
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
| Object | Condition | 是否会释放锁 |
|---|---|---|
| wait | await | 会释放锁 |
| notify | signal | 不会释放锁 |
| notifyAll | signalAll | 不会释放锁 |
image.png
1 调用signal，线程0开始正常输出，说明await和Object中的wait一样，signal和Object中的notify 一样
2 先输出wait，在输出signal，也就是说await也会释放锁
| Object | Condition | 是否会释放锁 |
|---|---|---|
| wait | await | 会释放锁 |
| notify | signal | 不会释放锁 |
| notifyAll | signalAll | 不会释放锁 |
