线程池基础

1.男女合伙吃饭

public class DeadLock {
    public static Object a = new Object();
    public static Object b = new Object();
}

public class Boy extends Thread{
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (DeadLock.a){
            System.out.println(Thread.currentThread().getName()+"获得一根a");
            synchronized (DeadLock.b){
                System.out.println(Thread.currentThread().getName()+"获得一根b");
                System.out.println("可以吃饭了");
            }
        }
    }
}

public class girl extends Thread{
    @Override
    public void run() {
        synchronized (DeadLock.b){
            System.out.println(Thread.currentThread().getName()+"获得一根b");
            synchronized (DeadLock.a){
                System.out.println(Thread.currentThread().getName()+"获得一根a");
                System.out.println("可以吃饭了");
            }
        }
    

public class dome {
    public static void main(String[] args) {
        Boy boy = new Boy();
        boy.setName("王文超");
        girl girl = new girl();
        girl.setName("大美女");
        boy.start();
        girl.start();
    }
}

2.存钱取钱

public class BankCard {
    //余额
    private double qian;
    //盘对是否有钱
    private boolean flag=false;



    public Double getQian() {
        return qian;
    }

    public void setQian(Double qian) {
        this.qian = qian;
    }
    public synchronized void take(Double money)  {
        if(flag==false){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取钱
        this.qian = this.qian - money;
        System.out.println(Thread.currentThread().getName()+"从卡中取出"+money+";卡中余额为："+this.qian);
        flag=false;
        //唤醒等待
        this.notify();
    }
    public synchronized void save(Double money) {
        if(flag==true){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //存钱
        this.qian = this.qian + money;
        System.out.println(Thread.currentThread().getName()+"往卡中存了"+money+";卡中余额为："+this.qian);
        flag=true;

        //唤醒等待
        this.notify();

    }

}

public class Girl implements Runnable{
private BankCard bankCard;

    public Girl(BankCard bankCard) {
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
             bankCard.take(1000.0);
        }
    }
}

public class Man implements Runnable{
private BankCard bankCard;

    public Man(BankCard bankCard) {
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
             bankCard.save(1000.0);
    }}
}

public class deom {
    public static void main(String[] args) {
        BankCard bankCard = new BankCard();
        //开启任务都对象
        Man man = new Man(bankCard);
        Girl girl = new Girl(bankCard);
        //创建线程
        Thread wang = new Thread(man,"wang");
        Thread wen = new Thread(girl,"wen");
        //开启线程
        wen.start();
        wang.start();
    }
}

线程池

public class dome {
    public static void main(String[] args) {
        //单一线程池  要求队列有序运行
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建固定长度的线程池对象
        //ExecutorService executorService = Executors.newFixedThreadPool(2);
        //创建可变线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        //创建延迟线程池10秒  长度为3
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 10; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"======================================");
                }
            },10, TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

public class dome {
    public static void main(String[] args) {
        LinkedBlockingDeque linkedBlockingDeque = new LinkedBlockingDeque(3);
        //核心数，最大线程数，空闲时间，时间单位，杜塞队列
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(2, 5, 10, TimeUnit.SECONDS, linkedBlockingDeque);
        for (int i = 0; i < 8; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"=============================");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

public class dome {
    public static void main(String[] args)throws Exception {
        //创建任务
        my my = new my();
        //转换runable类型
        FutureTask futureTask = new FutureTask(my);

        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
       /* my2 my2 = new my2();
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Future<Integer> submit = executorService.submit(my);
        Future<Integer> submit2 = executorService.submit(my2);
        //线程执行完毕后才会把结果返回给变量
        Integer integer = submit.get();
        Integer integer2 = submit2.get();
        System.out.println(integer+integer2);*/
    }
}
class my implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <=50 ; i++) {
            sum+=i;
        }
        return sum;
    }
}
class my2 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 51; i <=100 ; i++) {
            sum+=i;
        }
        return sum;
    }
}