线程面试点

一时失言乱红尘 2022-12-17 07:28 90阅读 0赞

## 线程的获取4中方式 ##

继承Thread，实现Runnable 和 Callable接口，用工具类Executors工具类从线程池对象中获取线程

## Lock锁比synchronized的优势 ##

lock 锁实现了线程的有序调度，可以实现多个线程接力，如下订单，减库存，发消息

而synchronized由cpu随机调度，

如果你要实现：多个线程下单，减库存，发短信的有序进行，就需要用lock来完成

Lock 替代了 synchronized 方法和语句的使用   Condition类中 await(),signal(),signalAll()替代了Object监视器方法的使用,即wait(),notify(),notifyAll()

Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象

在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决

synchronized无法实现读写锁，Lock锁可以ReentrantReadWriteLock

## Callable接口与Runnable接口的区别 ##

callable接口有返回值，有泛型，需要抛出异常

Runnable不返回任务执行结果，Callable可返回任务执行结果

Callable在任务无法计算结果时抛出异常，而Runnable不能

Runnable任务可直接由Thread的start方法或ExecutorService的submit方法去执行

## Runnable的子接口的实现类与Callable接口有关系 ##

Runnable 的子接口 RunnableFuture<v> 的实现类FutureTask 构造器中可以传入Callable接口的实现类

![2020102221225081.png][]

public static void main(String[]args) throws InterruptedException, ExecutionException {
        FutureTask ft = new FutureTask(new Callable(){
            @Override
            public Object call() throws Exception {
                System.out.println("come");
                return 543;
            }
        });
        new Thread(ft,"xxx").start();
        //获取返回值
        System.out.println("返回值："+ft.get());
    }

## 线程池 ##

线程池避免了线程的重复创建，用完后抛回池中，实现线程的复用，往往不知道几个线程够用，线程够用就不创建，不够用时自己创建

总纲接口 Executor , 子接口ExecutorService 有方法submit()和shutdown() submit的参数是Callable或者Runnable接口，返回值用Future类型接收, 获取线程的工具类Exectors, ExecutorService的子接口ScheduledExecutorService 有方法 schedule()和shutdown() ，可以实现延时调用

线程池的执行方法有俩个，一个是excute（没有返回），另一个是submit（返回一个Future<>）

// ExecutorService的submit方法如下：
     
       public Future<?> submit(Runnable task) {
            ThreadPoolExecutor executor = this.getThreadPoolExecutor();
    
            try {
                return executor.submit(task);
            } catch (RejectedExecutionException var4) {
                throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, var4);
            }
        }
    
        public <T> Future<T> submit(Callable<T> task) {
            ThreadPoolExecutor executor = this.getThreadPoolExecutor();
    
            try {
                return executor.submit(task);
            } catch (RejectedExecutionException var4) {
                throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, var4);
            }
        }

## 普通的同步方法默认的锁对象 是this， 而不是单前的同步方法或代码块，静态的同步方法默认的锁对象是 当前类.class ##

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法

所有的非静态同步方法用的都是同一把锁——-实例对象本身

所有的静态同步方法用的也是同一把锁——-类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

## 线程的生命周期状态 ##

Thread 里面定义了内部枚举类： public enum State 定义了线程的状态

新建——就绪——运行——阻塞——停止（死亡）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MDQyOTM4_size_16_color_FFFFFF_t_70][]

## 线程释放锁的操作 ##

l当前线程的同步方法、同步代码块执行结束

2当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

3当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

4当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

## 线程不会释放锁的操作 ##

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）， 应尽量避免使用suspend()和resume()来控制线程

## sleep和wait的区别 ##

1、这两个方法来自不同的类分别是Thread和Object

2、最主要的是sleep方法没有释放锁，二wait方法释放了锁

3、wait, notify,notifyAll只能在同步控制方法或者同步控制块中使用，而sleep可以在任何地方使用

4、sleep 必须捕获异常，而wait,notify和notifyAll 不需要捕获异常

## 线程的通信 ##

线程通信的常见方法： 这些方法定义在Object类中

wait()     语法：锁对象名：wait()

调用方法的必要条件：当前线程必须具有对该对象的监控全（加锁）

该线程中调用了wait方法，意思是该线程处于等待状态，直到该锁对象上其他线程调用了notify或notify（），等待结束

该线程中调用了wait方法，则释放锁，进入等待状态其他线程可以抢占cpu,

该线程等待结束后，需要重新抢占cpu，抢到后继续从刚才断点处往下执行

必要条件：wait方法的调用者与 该线程的锁对象必须是同一个

A线程调用则A线程等待，自己不会醒，需要其他线程唤醒

wait(long timeout） 到一定时间也会醒来 或者notify()唤醒

notify()  语法：锁对象名：notify（）

唤醒同一个锁对象上的其他正在等待的线程，如果该锁对象上有多个线程等待，则会随机选择一个线程唤醒

必要条件：notify的调用者与该线程的所对象必须是同一个

A线程调用，唤醒的是其他单个线程

notifyAll()      唤醒同一个锁对象上的其他所有正在等待的线程（可以唤醒多个）

## submit和excute的区别 ##

*  接收的参数不一样
 *  submit有返回值Future<?>，而execute没有
 *  submit方便异常处理

<T> Future<T> submit(Runnable task, T result);
    <T> Future<T> submit(Callable<T> task);
    Future<?> submit(Runnable task);
    void execute(Runnable command);

[2020102221225081.png]: /images/20221123/4510d1b735624876993d4902ba4767e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MDQyOTM4_size_16_color_FFFFFF_t_70]: /images/20221123/40bad17713c1424aa5446ff6aa29abf8.png