1.什么是死锁 2.线程都有哪些状态3.线程通信 4.线程池

1.什么是死锁

死锁是指两个或多个事务在同一资源上相互占用，并请求锁定对方的资源，从而导致恶性循环的现象。

当多个进程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进，这种情况就是死锁。

很显然，如果没有外力的作用，那么死锁涉及到的各个进程都将永远处于封锁状态。

如何解决死锁: (1) 减少同步代码块的嵌套。 （2）设置锁的超时时间。（3）可以使用安全类-jdk提高的安全类。  

2.线程都有哪些状态

1. NEW（新建）：线程被创建但还未启动。
2. RUNNABLE（可运行）：线程正在Java虚拟机中执行，但可能在等待操作系统资源（如处理器）。
3. BLOCKED（阻塞）：线程被阻塞并等待监视器锁定，以进入同步块或方法。
4. WAITING（等待）：线程等待其他线程执行特定操作，进入等待状态直到被唤醒。
5. TIMED_WAITING（计时等待）：线程等待其他线程执行特定操作，但只等待一段时间，超时后会自动唤醒。
6. TERMINATED（终止）：线程已经执行完毕或异常终止。

3.线程通信

 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。

  

sleep和wait方法的区别?

(1) 来自不同的类: sleep来自于Thread， wait来自Object类。

(2) 是否释放锁资源: sleep不会释放锁资源。wait会释放锁资源。

(3) 用法: sleep时间到了自然会醒，而wait需要调用notify或notifyAll()方法唤醒。

notify和notifyAll()方法的区别?

1.notify随机唤醒等待队列中一个线程，而notifyAll会唤醒等待队列中所有的线程。

 4.线程池

public class Test {
    public static void main(String[] args) {
        //1.创建一个固定长度的线程池。
//        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //2. 单一线程池。
//        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //3. 可变线程池--缓存线程池
//        ExecutorService executorService = Executors.newCachedThreadPool();
        //4. 延迟线程池。
//        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);

//        for(int i=0;i<100;i++) {
//            executorService.submit(new Runnable() {
//                public void run() {
//                    System.out.println(Thread.currentThread().getName() + "~~~~~~~~~~~~~~~~~~~");
//                }
//            });
            executorService.schedule(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "~~~~~~~~~~~~~~~~~~~");
                }
            },10, TimeUnit.SECONDS);
//        }
//        executorService.shutdown();
        //上面通过Executors工具类创建线程池，但是阿里巴巴不建议使用。阿里建议使用原生的模式创建线程池。
        /*
                                int corePoolSize,核心线程的个数
                              int maximumPoolSize,最多的线程个数
                              long keepAliveTime, 线程空闲时间。
                              TimeUnit unit, 空闲的单位
                              BlockingQueue<Runnable> workQueue：等待队列
         */

        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(5);//最多5等待的任务
        ThreadPoolExecutor executor=new ThreadPoolExecutor(5,10,10, TimeUnit.SECONDS,workQueue);
        //灵活：
        for(int i=0;i<25;i++){
            executor.submit(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~");
                }
            });
        }

    }
}

5. Callable创建线程

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    /*   MyCallable myCallable=new MyCallable();
        FutureTask<Integer> task=new FutureTask<Integer>(myCallable);//把线程任务封装到该类中，该类可以获取线程任务执行后的结果.
       Thread t=new Thread(task);
      t.start();

       System.out.println(task.get());*/
        //发现线程执行非常麻烦。都使用线程池来执行任务。---不要自己创建线程对象，而是使用线程池中的对象
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> submit =executorService.submit(new MyCallable());
        System.out.println(submit.get());

    }
}
class MyCallable implements Callable<Integer> {

    //线程任务：
    public Integer call() throws Exception {
        int sum=0;
        for(int i=0;i<=10;i++){
            sum+=i;
        }
        return sum;
    }
}

class MyRunnable implements  Runnable{

    public void run() {

    }
}