JAVA高级篇--线程

目录

1.线程死锁

2.线程通信

 3.线程池

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

5.创建线程的第三种方式

6.手动锁

---

1.线程死锁

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

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

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

操作死锁的原因：

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

如何解决死锁：

1.尽量减少锁的嵌套

2.可以使用一些安全类

3.可以使用Lock中的枷锁，设置枷锁时间

2.线程通信

线程通信中使用的方法

例如存钱取钱

先存钱在取钱

sleep和wait的区别

1.所在的类不同。sleep属于thread类，wait属于Object类。

2.使用的方法：sleep可以使用在任何代码块，wait只能在同步代码块中。

3.是否释放锁资源：sleep不释放锁资源，wait会释放锁资源。

4.sleep时间到了自动唤醒，wait必须需要使用notify和notifyAll唤醒

notify和notifyAll区别

 3.线程池

什么是线程池

该赤字终于向存储若干个线程对象。整个池子就是线程池

线程池的作用：

 线程池的创建方式

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

​ 它的实现接口: ExecutorService.

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

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

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

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

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

package com.lpt.demo05;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test01 {
    public static void main(String[] args) {
        //单一线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        //延迟线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        //创建定长线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(3);
        //创建可变线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 1; i < 10; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "========");
                }
            },10, TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

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

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

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

package com.lpt.demo05;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test02 {
    public static void main(String[] args) {
        /**
         * int corePoolSize, 核心线程数
         * int maximumPoolSize 最大线程数
         * long KeepAliveTime 空闲时间
         * TimeUnit unit, 时间单位
         *BlockingQueue<Runnable> WorkQueue  阻塞对象
         * **/
        LinkedBlockingDeque linkedBlockingDeque = new LinkedBlockingDeque(3);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,5,10,TimeUnit.SECONDS,linkedBlockingDeque);
        for (int i = 1; i < 9; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "========");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

5.创建线程的第三种方式

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

package com.lpt.demo06;

import java.util.concurrent.*;

public class Test04 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        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<=50;i++){
            sum+=i;
        }
        return sum;
    }
}
class My2 implements Callable<Integer>{


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

6.手动锁

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

lock（）方法。

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