3.31作业

package com.qiku.day24;
//1、 使用synchronized 、wait() 、notifyAll()方法实现 生产者消费者模型
public class Zy1 {
    private static int count = 0;
    private static final int FULL = 100;
    private static final String LOCK = "对象锁";
    class Producer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (LOCK) {
                    if (count == FULL) {
                        try {
                            LOCK.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println("生产者生产，库存：" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (LOCK) {
                    if (count == 0) {
                        try {
                            LOCK.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    count--;
                    System.out.println("消费者消费，库存余：" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) {
        Zy1 hw = new Zy1();
        Producer producer = hw.new Producer();
        Consumer consumer = hw.new Consumer();
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);
        t1.start();
        t2.start();
    }
}

package com.qiku.day24;
import java.util.concurrent.Callable;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

//2、 使用3种不同的方式创建线程
public class Zy2 {
    public class ThreadTest {
        public static void main(String[] args) {
            ExtendsCreatThread ect = new ExtendsCreatThread("继承的线程");
            Thread t1 = new Thread(ect);
            ImplementsRunnableThread irt = new ImplementsRunnableThread();
            Thread t2 = new Thread(irt);
            ImplementsCallableThread ict = new ImplementsCallableThread();
            FutureTask<String> task = new FutureTask<String>(ict);
            Thread t3 = new Thread(task);
            t1.start();
            t2.start();
            t3.start();
        }
    }

}
//1、集成Thread类
 class ExtendsCreatThread extends Thread {

    public ExtendsCreatThread(String name) {
        super(name);
    }

    public ExtendsCreatThread() {
    }

    @Override
    public void run() {
        System.out.println("继承Thread类的创建方法");
    }
}
//2、实现Runnable接口
 class ImplementsRunnableThread implements Runnable {

    @Override
    public void run() {
        System.out.println("实现Runnable接口方式创建的线程");
    }
}
//3、实现Callable<V>接口


class ImplementsCallableThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        String str = "实现Callable接口创建的线程";
        System.out.println(str);
        return str;
    }
}

package com.qiku.day24;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//3、 测试3种不同线程池，体会下区别
public class Zy3 {
    public static void main(String[] args) {
        ExecutorService service1 = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            service1.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        service1.shutdown();
        ExecutorService service2 = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            service2.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        service2.shutdown();
        ExecutorService service3 = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            service3.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        service3.shutdown();
    }
}

4、 默写出线程的线程的生命周期，以及不同状态做什么事情？

Thread t = new Thread();//创建出线程    不执行
t.start();//启动线程到就绪状态，等待调配器分配时间片   不执行
分到时间片后  //从就绪状态到运行状态      执行
    时间片结束后，如果线程任务未完成则会回到就绪状态继续等待分配时间片
                如果线程任务完成，线程进入消亡状态
    
yield();//使线程状态变为 就绪状态  继续等待分配时间片   不执行
线程如果在运行状态时遇到阻塞，如（ sleep(times)、join()、wait()）,会等待阻塞状态结束  过程中 不执行
    阻塞状态结束后，线程则从阻塞状态 变为 就绪状态，等待分配时间片，得到时间片后会从阻塞位置继续完成任务