zoukankan      html  css  js  c++  java
  • 面试系列<3>——java并发

    面试系列——java并发

    一、使用线程

    有三种使用线程的方法:

    • 实现Runnable接口
    • 实现Callable接口
    • 继承Thread类

    实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。

    实现Runnable接口

    public class MyRunnable implements Runnable {
        @Override
        public void run() {
            // ...
        }
    }
    

    使用Runnable实例再创建一个Thread实例,然后调用Thread实例的start方法来启动线程。

    public static void main(String[] args) {
        MyRunnable instance = new MyRunnable();
        Thread thread = new Thread(instance);
        thread.start();
    }
    

    实现Callable接口

    与Runnable相比,Callable可以有返回值,返回值通过FutureTask进行封装

    public class MyCallable implements Callable<Integer> {
        public Integer call() {
            return 123;
        }
    }
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<>(mc);
        Thread thread = new Thread(ft);
        thread.start();
        System.out.println(ft.get());
    }
    

    继承 Thread 类

    同样是需要实现run()方法,因为Thread类也实现了Runable接口。

    当调用start()方法启动一个线程时,虚拟机会将该线程放入就绪队列中等待被调度,当一个线程被调度时会执行该线程的run方法。

    public class MyThread extends Thread {
        public void run() {
            // ...
        }
    }
    
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
    }
    

    实现接口VS继承Thread

    实现接口会更好一些,因为:

    • java不支持多重继承,因此继承了Thread类就无法继承其他类,但是可以实现多个接口
    • 类可能只要求可执行就行,继承整个Thread类开销过大。

    二、基础线程机制

    线程池有什么作用?

    线程池作用就是限制系统中执行线程的数量。

    1、提高效率 创建好一定数量的线程放在池中,等需要使用的时候就从池中拿一个,这要比需要的时候创建一个线程对象要快的多。

    2、方便管理 可以编写线程池管理代码对池中的线程统一进行管理,比如说启动时有该程序创建100个线程,每当有请求的时候,就分配一个线程去工作,如果刚好并发有101个请求,那多出的这一个请求可以排队等候,避免因无休止的创建线程导致系统崩溃。

    Executor

    Executor管理多个异步任务的执行,而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰,不需要进行同步操作。

    主要有三种Executor:

    • CachedThreadPool:一个任务创建一个线程,无限扩大,适合轻负载。
    • FixedThreadPool:所有任务只能使用固定大小的线程,固定线程池,适合重负载。
    • SingleThreadExecutor:相当于大小为1的FixedThreadPool.创建单线程的线程池,适用于需要保证顺序执行各个任务。
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyRunnable());
        }
        executorService.shutdown();
    }
    

    Daemon

    守护线程是程序运行时在后台提供服务的线程,不属于程序中不可或缺的部分。

    当所有非守护线程结束时,程序也就终止,同时会杀死所有守护线程。

    mian()属于非守护线程。

    在线程启动之前使用setDaemon()方法可以将一个线程设置为守护线程。

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.setDaemon(true);
    }
    

    sleep()

    Thread.sleep(millisec)方法会休眠当前正在执行的线程,millisec单位为毫秒。

    sleep()可能会抛出InterruptedExecption,因为异常不能跨线程传播回main()中,因此必须在本地处理。线程中抛出的其他异常也同样需要在本地进行处理。

    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    

    三、中断

    一个线程执行完毕之后会自动结束,如果在运行过程中发生异常也会提前结束。

    InterruptedExecption

    通过调用一个线程的interrupt()来中断该线程,如果该线程处于阻塞、限期等待或者无限期等待状态,那么就会抛出InterruptedException,从而提前结束该线程。但是不能中断I/O阻塞和suynchronized锁阻塞。

    对于以下代码,在main()中启动一个线程之后再中断它,由于线程中调用了Thread.sleep()方法, 因此会抛出一个 InterruptedException,从而提前结束线程,不执行之后的语句。

    public class InterruptExample {
    
        private static class MyThread1 extends Thread {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("Thread run");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new MyThread1();
        thread1.start();
        thread1.interrupt();
        System.out.println("Main run");
    }
    
    Main run
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at InterruptExample.lambda$main$0(InterruptExample.java:5)
        at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)
    

    Executor 的中断操作

    调用Executor的shutdown()方法会等待线程都执行完毕之后再关闭,但是如果调用的是shutdownNow()方法,则相当于调用每个线程的interrupt()方法。

    以下使用Lambda创建线程,相当于创建了一个匿名内部线程。

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("Thread run");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdownNow();
        System.out.println("Main run");
    }
    
    Main run
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
        at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at java.lang.Thread.run(Thread.java:745)
    

    如果只想中断 Executor 中的一个线程,可以通过使用 submit() 方法来提交一个线程,它会返回一个 Future<?> 对象,通过调用该对象的 cancel(true) 方法就可以中断线程。

    Future<?> future = executorService.submit(() -> {
        // ..
    });
    future.cancel(true);
    

    四、互斥同步

    java提供了两种锁机制来控制多个线程对共享资源的互斥访问,第一个是JVM实现的synchronized,而另一个是JDK实现的ReentrantLock。

    synchronized

    1、同步一个代码块

    public void func() {
        synchronized (this) {
            // ...
        }
    }
    

    它只作用于同一个对象,如果调用两个对象上的同步代码块,就不会进行同步。

    对于以下代码,使用 ExecutorService 执行了两个线程,由于调用的是同一个对象的同步代码块,因此这两个线程会进行同步,当一个线程进入同步语句块时,另一个线程就必须等待。

    public class SynchronizedExample {
    
        public void func1() {
            synchronized (this) {
                for (int i = 0; i < 10; i++) {
                    System.out.print(i + " ");
                }
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e1.func1());
    }
    
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
    

    对于一下代码,两个线程调用了不同对象的同步代码块,因此这两个线程就不需要同步。从输出结果看出,两个线程交叉执行。

    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        SynchronizedExample e2 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e2.func1());
    }
    
    0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
    

    2、同步一个方法

    public synchronized void func () {
        // ...
    }
    

    它和同步代码块一样,作用于同一个对象

    3、同步一个类

    public void func() {
        synchronized (SynchronizedExample.class) {
            // ...
        }
    }
    

    作用于整个类,也就是说两个线程调用同一个类的不同对象上的这种同步语句,也会进行同步。

    public class SynchronizedExample {
    
        public void func2() {
            synchronized (SynchronizedExample.class) {
                for (int i = 0; i < 10; i++) {
                    System.out.print(i + " ");
                }
            }
        }
    }
    
    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        SynchronizedExample e2 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func2());
        executorService.execute(() -> e2.func2());
    }
    
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
    

    4、同步一个静态方法

    public synchronized static void fun() {
        // ...
    }
    

    作用于整个类。

    ReentrantLock

    ReentrantLock是java.util.concurrent(J.U.C)包中的锁。

    public class LockExample {
    
        private Lock lock = new ReentrantLock();
    
        public void func() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.print(i + " ");
                }
            } finally {
                lock.unlock(); // 确保释放锁,从而避免发生死锁。
            }
        }
    }
    
    public static void main(String[] args) {
        LockExample lockExample = new LockExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> lockExample.func());
        executorService.execute(() -> lockExample.func());
    }
    
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
    

    比较

    1、锁的实现

    synchronized是JVM实现的,而ReentrantLock是JDK实现的。

    2、性能

    新版本java对synchronized进行了很多优化,例如自旋锁等,synchronized与ReentrantLock大致相同。

    3、等待可中断

    当持有锁的线程长期不释放锁的时候,正在等待的线程可以选择放弃等待,改为处理其他事情。

    ReentrantLock 可中断,而 synchronized 不行。

    4、公平锁

    公平锁是指多个线程在等待同一个锁时,必须按照申请锁的时间顺序来依次获得锁。

    synchronized 中的锁是非公平的,ReentrantLock 默认情况下也是非公平的,但是也可以是公平的。

    5、锁绑定多个条件

    一个 ReentrantLock 可以同时绑定多个 Condition 对象。

    使用选择

    除非使用ReentrantLock的高级功能,否则优先使用synchronized。这是因为synchronized是JVM实现的一种锁机制,JVM原生地支持,而ReentrantLock不是所有的JDK版本都支持。并且使用synchronized不用担心没有释放锁而导致死锁问题,因为JVM会确保锁的释放。
    五、线程协作
    https://www.cnblogs.com/jimlau/p/12463663.html
    六、线程状态
    https://www.cnblogs.com/jimlau/p/12463663.html

  • 相关阅读:
    Java实现 LeetCode 343 整数拆分(动态规划入门经典)
    Java实现 LeetCode 342 4的幂
    Java实现 LeetCode 342 4的幂
    Java实现 LeetCode 342 4的幂
    Java实现 LeetCode 341 扁平化嵌套列表迭代器
    Java实现 LeetCode 341 扁平化嵌套列表迭代器
    Java实现 LeetCode 341 扁平化嵌套列表迭代器
    Java实现 LeetCode 338 比特位计数
    H264(NAL简介与I帧判断)
    分享一段H264视频和AAC音频的RTP封包代码
  • 原文地址:https://www.cnblogs.com/jimlau/p/14687811.html
Copyright © 2011-2022 走看看