多线程/线程池/锁相关面试总结

多线程(线程池)
启动线程调用start() 方法,run()方法是线程启动后需要执行的方法。

1. 继承thread类
2. 实现runnable 接口
3. 实现callable 接口(call()方法,有返回值通过future对象的get()方法可以获取返回值,get()方法会阻塞,直到任务结果返回)
Callable 和 Future接口的区别
1. Callable规定的方法是call(),而Runnable规定的方法是run()。 
2. Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。  
3. call()方法可抛出异常,而run()方法是不能抛出异常的。 
4. 运行Callable任务可拿到一个Future对象, Future表示异步计算的结果。 
5. 它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。 
6. 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。 
7. Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务
线程池:

线程池类继承图(1).jpg

常用的是 ThreadPoolExecutor 类 自定义 corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit, BlockingQueue

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

线程池公式 :

maximumPoolSize = 2 * corePoolSize = 4 * cpu线程数
Executors线程池工具类:
Executors.new SingleThreadPoolExecutor(); 最大线程数为1
Executors.new FixedThreadPool() :核心线程数 = 最大线程数
Executors.new CachedThreadPool() :缓存线程池
Executors.new ScheduledThreadPoolExecutor(5) :延迟/周期性线程池     

single和fixed阻塞队列最大为 Interger.MAX_VALUE [2的31次方];
cached 和scheduled 最大线程数为 Interger.MAX_VALUE [2的31次方];

===========================================================================

锁 :

锁分类:
  • 可重入锁:Synchronized和ReentrantLook都是可重入锁,锁的可重入性标明了锁是针对线程分配方式而不是针对方法。例如调用Synchronized方法A中可以调用Synchronized方法B,而不需要重新申请锁。
  • 读写锁:按照数据库事务隔离特性的类比读写锁,在访问统一个资源(一个文件)的时候,使用读锁来保证多线程可以同步读取资源。ReadWriteLock是一个读写锁,通过readLock()获取读锁,通过writeLock()获取写锁。
  • 可中断锁:可中断是指锁是可以被中断的,Synchronized内置锁是不可中断锁,ReentrantLock可以通过lockInterruptibly方法中断显性锁。例如线程B在等待等待线程A释放锁,但是线程B由于等待时间太久,可以主动中断等待锁。
  • 公平锁:公平锁是指尽量以线程的等待时间先后顺序获取锁,等待时间最久的线程优先获取锁。synchronized隐性锁是非公平锁,它无法保证等待的线程获取锁的顺序,ReentrantLook可以自己控制是否公平锁。
两种锁的底层实现:
  • Synchronized:底层使用指令码方式来控制锁的,映射成字节码指令就是增加来两个指令:monitorenter和monitorexit。当线程执行遇到monitorenter指令时会尝试获取内置锁,如果获取锁则锁计数器+1,如果没有获取锁则阻塞;当遇到monitorexit指令时锁计数器-1,如果计数器为0则释放锁。
  • Lock:底层是CAS乐观锁,依赖AbstractQueuedSynchronizer类,把所有的请求线程构成一个CLH队列。而对该队列的操作均通过Lock-Free(CAS)操作。
Synchronized和Lock比较
  • Synchronized是关键字,内置语言实现,Lock是接口。
  • Synchronized在线程发生异常时会自动释放锁,因此不会发生异常死锁。Lock异常时不会自动释放锁,所以需要在finally中实现释放锁。
  • Lock是可以中断锁,Synchronized是非中断锁,必须等待线程执行完成释放锁。
  • Lock可以使用读锁提高多线程读效率。
sychronized :
Lock :使用Lock必须在try…catch…块中进行,并且将释放锁的操作放在finally块中进行
ReentrantLock: (用法lock.tryLock() )
    // 获取锁  
    void lock()   

    // 如果当前线程未被中断,则获取锁,可以响应中断  
    void lockInterruptibly()   

    // 返回绑定到此 Lock 实例的新 Condition 实例  
    Condition newCondition()   

    // 仅在调用时锁为空闲状态才获取该锁,可以响应中断  
    boolean tryLock()   

    // 如果锁在给定的等待时间内空闲,并且当前线程未被中断,则获取锁  
    boolean tryLock(long time, TimeUnit unit)   

    // 释放锁  
    void unlock() 

tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true;如果获取失败(即锁已被其他线程获取),则返回false,也就是说,这个方法无论如何都会立即返回(在拿不到锁时不会一直在那等待)。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false,同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁,则返回true。

ReentrantReadWriteLock : 读写锁 (用法 lock.readLock().lock())
要点 : 共享读,独占写
//返回用于读取操作的锁  
Lock readLock()   
//返回用于写入操作的锁  
Lock writeLock() 

代码示例 :

// 读数据
    public void get() {
        // 加读锁
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName() + " have read data :" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放读锁
            lock.readLock().unlock();
        }
    }

    // 写数据
    public void put(Object data) {
        // 加写锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");
            Thread.sleep((long) (Math.random() * 1000));
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放写锁
            lock.writeLock().unlock();
        }

    }
}

评论

暂无评论