还被面试官怼并发编程？来，吃点能量！Java并发编程技术

时间 2019-11-30

标签面试并发编程吃点能量 java 技术栏目快乐工作繁體版

原文原文链接

1、线程池相关

线程超级详解：blog.csdn.net/cuigx1991/a…html

线程池：www.importnew.com/19011.htmljava

www.jianshu.com/p/098819be0…面试

ExecutorService

blog.csdn.net/yuzhiboyi/a…编程

Callable与Runnable

blog.csdn.net/lu123535884…bash

Callable能够返回结果，可是runnable不行。并发

上代码：

public  class TestCallable implements Callable<String>{

    @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<String> 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方法结束。异步

CountDownLatchide

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

异步转同步须要注意ui

1）异步的数据必定要是在子线程里，不然会形成当前线程卡顿。

2）若是须要在主线程里同步返回数据，可是取数据走的是子线程，子线程不要使用new Handler(Looper.getMainLooper()) 来作延时操做，不然会形成子线程回调没法countDownLatch减少，最终主线程一直在等待。

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

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

3）await方法在开其余线程以后再执行，不然其余线程尚未开启起来就把当前线程阻塞了。

2、线程交互

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

相关博客：blog.csdn.net/qq_26504875…

常见异常：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 wait

MyThread2 1516939281374

MyThread2 wait

MyThread1 1516939281374

MyThread2 1516939281374

能够发现2个线程任务是交替执行的

3、HandlerThread

www.cnblogs.com/coding-way/…

4、InputStream阻塞

www.cnblogs.com/MyFavorite/…

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

www.cnblogs.com/dolphin0520…

java中volatile关键字的含义

www.cnblogs.com/aigongsi/ar…

blog.csdn.net/javazejian/…

最后

喜欢的能够关注个人公众号，java小瓜哥的分享平台。平时整理的技术文和面试文还有许多资料都放在里面了