多线程的死锁

线程死锁。

当A线程拥有锁资源a时，这时A线程需要锁资源b， 而B线程拥有锁资源b，这时B线程需要锁资源a, 这样会导致A等待B线程释放资源b, B线程等待A线程释放锁资源a。 从而二个处于永久等待。从而操作死锁。

例子: 情人节---两个情人去餐厅吃饭---必须具有两个筷子。

男方拥有一根筷子，女方拥有另一个筷子。

操作死锁得原因:

1. 锁与锁之间有嵌套导致。

如何解决死锁:

1. 尽量减少锁得嵌套。
2. 可以使用一些安全类。
3. 可以使用Lock中得枷锁，设置枷锁时间。

线程通信中使用得方法有哪些?

 

 

 

 

sleep和wait得区别?

1.所在得类不同。sleep属于Thread类，wait属于Object类。
2.使用的地方: sleep可以使用再任何代码块。wait只能再同步代码块中。
3.是否释放锁资源: sleep不释放锁资源，wait会释放锁资源。
4.sleep时间到了自动唤醒，wait必须需要使用notify和notifyAll唤醒

notify和notyfyAll区别?

 

线程池。

什么是线程池!

该池子中预先存储若干个线程对象。整个池子就是线程池。

 

线程池的作用:

 

线程池的创建方式有哪些?

所有的线程池---封装了一个父接口---java.util.concurrent.Executor.

它的实现接口: ExecutorService.

有一个工具类。Executors可以帮你创建相应的线程池。

[1] 创建单一线程池 newSingleThreadExecutor()

[2] 创建定长线程池。newFixedThreadPool(n);

[3] 创建可变线程池. newCachedThreadPool()

[4] 创建延迟线程池 .newScheduledThreadPool(n);

 *    Executor:线程池的根类。里面有一个方法。execute执行线程任务的方法Runnable类型的任务
 *       ExecutorService: 线程池的子接口
 *           shutdown(); 关闭线程池。需要等待线程池中任务执行完毕后才会关闭。
 *           shutdownNow(): 立即关闭线程池。
 *           isTerminated():判断线程池是否终止了。
 *           submit(): 提交任务给线程池中线程对象、Runnable和Callable类型的任务。
 **/
public class Test01 {
    public static void main(String[] args) {
        //单一线程池: 适应场景:队列要求线程有序执行。
//        ExecutorService executorService = Executors.newSingleThreadExecutor();

        //创建固定长度的线程池对象
       // ExecutorService executorService = Executors.newFixedThreadPool(3);

        //创建可变长度的线程池
       // ExecutorService executorService = Executors.newCachedThreadPool();

        //创建延迟线程池对象
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

        for (int i = 0; i <5 ; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~~~~");
                }
            },10, TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

使用最原始的方式创建线程池

上面讲解的使用Executors创建线程池的方式，都是使用底层ThreadPoolExecutor，而阿里开发手册，建议使用最原始的方式。

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

public class Test02 {
    public static void main(String[] args) {
        /**
         * int corePoolSize, 核心线程数
*          int maximumPoolSize, 最大线程数
*          long keepAliveTime, 空闲时间
*          TimeUnit unit, 时间单位
*          BlockingQueue<Runnable> workQueue: 堵塞队列，
         *
         *  根据你自己的业务以及服务器配置来设置。
         */
        //LinkedBlockingDeque:可以设置等待的个数，如果不设置默认为Integer的最大值。
        BlockingQueue blockingQueue=new LinkedBlockingDeque(3);
        ThreadPoolExecutor threadPoolExecutor=
                new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,blockingQueue);


        for (int i = 0; i <5 ; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~");
                }
            });
        }

        threadPoolExecutor.shutdown();
    }
}

创建线程的第三种方式

实现Callable接口，它和实现Runnable接口差不多，只是该接口种的方法有返回值和异常抛出。

public class Test {
    public static void main(String[] args) throws Exception {
        My task=new My();
        FutureTask futureTask=new FutureTask(task);
        Thread t1=new Thread(futureTask);
        t1.start();
        //自建创建线程对象并提交Callable类型的任务是比较麻烦的，需要封装到一个FutureTask类种， 建议使用线程池来提交任务

        System.out.println(futureTask.get());
//        My2 task2=new My2();
//
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Future<Integer> future = executorService.submit(task);
//        Future<Integer> future2 = executorService.submit(task2);
//
        Integer sum = future.get();//需要等线程执行完毕后，才会把结果返回给该变量、
//        Integer sum2 = future2.get();
//        System.out.println(sum+sum2);

        //应用场景: 适合大文件上传。

    }
}
class My implements Callable<Integer>{


    //1~50的和
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i=1;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}
class My2 implements Callable<Integer>{


    //1~50的和
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i=51;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}

手动锁

Lock它是手动锁的父接口，它下面有很多实现类。

lock（）方法。

unlock()释放锁资源，放在finally中