Java并发编程技术

一、线程池相关

线程超级详解：http://blog.csdn.net/cuigx1991/article/details/48219741

线程池：http://www.importnew.com/19011.html

              https://www.jianshu.com/p/098819be088c

ExecutorService

http://blog.csdn.net/yuzhiboyi/article/details/7775266

Callable与Runnable

http://blog.csdn.net/lu123535884/article/details/49495833

Callable可以返回结果，但是runnable不行。

上代码：

public  class TestCallable implements Callable{

    @Override
    public String call() throws Exception {
        Thread.sleep(3000);
        return "Hello World";
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    TestCallable testCallable = new TestCallable();
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Future future = executorService.submit(testCallable);
    try {
        System.out.println(future.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.println("11111111111111");
}

可以发现我在TestCallable里加了个sleep，程序还是会后打印"111111111111"那一个串，说明TestCallable的线程会阻塞主线程，真正原因是future.get()会阻塞当前线程，直到callable的call方法结束 。

 

CountDownLatch

可以阻塞当前线程，等待另外一个线程执行完结果后将结果同步返回，异步转同步。

异步转同步需要注意

1）异步的数据一定要是在子线程里，否则会造成当前线程卡顿。

2）如果需要在主线程里同步返回数据，但是取数据走的是子线程，子线程不要使用new Handler(Looper.getMainLooper()) 来做延时操作，否则会造成子线程回调无法countDownLatch减小，最终主线程一直在等待。

在子线程中使用Handler的方法：

HandlerThread handlerThread = new HandlerThread("纯24协议对接收到的数据进行分析"){};
handlerThread.start();
mHandler = new Handler(handlerThread.getLooper());

3）await方法在开其他线程之后再执行，否则其他线程还没有开启起来就把当前线程阻塞了。

二、线程交互

 1.唤醒与等待（wait与notify）

  相关博客：http://blog.csdn.net/qq_26504875/article/details/50703961

  常见异常：http://blog.csdn.net/zhouxiaoyun0228/article/details/7757313

  注意事项：1)唤醒与等待是有严格的使用条件的，对象监听器只能在所监听的线程内调用。

       2)wait与notify只能在同步代码块里调用

       3）一般一个任务同步方法执行完，调用监听器wait当前线程。

       4）wait与notify虽然是object的方法，但是作用是作为锁来控制线程。

       5）wait与notify更适用于两个或多个协同工作的线程 

 

  代码实例：  

  2个交互的线程类：    

public class MyThread1 extends Thread{
    private Object lock;
    private int index = 0;

    public MyThread1(Object lock){
        this.lock = lock;
    }
    @Override
    public void run(){
        synchronized (lock) {
            while (true){
                System.out.println("MyThread1 "+System.currentTimeMillis());
                index++;
                if(index == 10){
                    lock.notify();
                    break;
                }
                if(index % 5 == 0){
                    try {
                        lock.notify();
                        System.out.println("MyThread1 wait");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    }
}

public class MyThread2 extends Thread{
    private Object lock;
    private int index = 0;

    public MyThread2(Object lock){
        this.lock = lock;
    }
    @Override
    public void run(){
        synchronized (lock) {
            while (true){
                System.out.println("MyThread2 "+System.currentTimeMillis());
                index++;
                if(index == 10){
                    lock.notify();
                    break;
                }
                if(index % 5 == 0){
                    try {
                        lock.notify();
                        System.out.println("MyThread2 wait");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

 2个交互线程的任务调用类：

public class Thread1Tasker implements ITask{
    private Object lock;
    private final static Thread1Tasker instance = new Thread1Tasker();
    public final static Thread1Tasker getInstance(){
        return instance;
    }

    public Thread1Tasker setLock(Object lock) {
        this.lock = lock;
        return this;
    }

    @Override
    public void start() {
        MyThread1 t1 = new MyThread1(lock);
        t1.start();
    }
}

public class Thread2Tasker implements  ITask{
    private Object lock;

    private final static Thread2Tasker instance = new Thread2Tasker();
    public final static Thread2Tasker getInstance(){
        return instance;
    }

    public Thread2Tasker setLock(Object lock) {
        this.lock = lock;
        return this;
    }


    @Override
    public void start() {
        MyThread2 t2 = new MyThread2(lock);
        t2.start();
    }
}

 main方法里调用任务：

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread1Tasker.getInstance().setLock(lock)
                .start();
        Thread2Tasker.getInstance().setLock(lock)
                .start();
    }
}

   

 结果打印输出：

 

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 wait

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 wait

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

 可以发现2个线程任务是交替执行的

  

三、HandlerThread

https://www.cnblogs.com/coding-way/p/5110125.html

四、InputStream阻塞

https://www.cnblogs.com/MyFavorite/archive/2010/10/19/1855758.html

五、Java并发编程：volatile关键字解析

http://www.cnblogs.com/dolphin0520/p/3920373.html

java中volatile关键字的含义

http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

https://blog.csdn.net/javazejian/article/details/52709857