多线程

创建多线程的方式

继承Thread类的方式

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run()
3. 创建Thread类的子类对象
4. 通过此对象调用start()

实现Runnable接口的方式

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法run()
3. 创建实现类对象
4. 将对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

注意点：

1. 启动一个线程，必须调用start()，不能调用run()的方式启动线程
2. 如果再启动一个线程，必须重写创建一个Thread子类的对象，调用此对象的start()

实现Callable接口的方式

1. call()可以有返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池的方式创建

实现线程池的好处

1. 提高响应速度（减少了创建新线程的时间）
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3. 便于线程管理

corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
        System.out.println(service.getClass());
        service1.setCorePoolSize(15);
        service1.setKeepAliveTime();
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

常用方法

方法	功能
start()	启动当前线程，调用当前线程的run()
run()	需要重写Thread类中的此方法，将创建线程要执行的操作声明在次方法中
currentThread()	静态方法，返回执行当前代码的线程
getName()	获取当前线程的名字
setName()	设置当前线程的名字
yield()	释放当前线程的执行权
join()	在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程b就结束阻塞状态
stop()	已过时，当执行次方法时，强制结束当前线程
sleep(long millitime)	让当前线程睡眠指定的millitime毫秒。在指定的millitime毫秒内，线程是阻塞状态
isAlive()	判断当前线程是否存活

线程的生命周期

线程的同步机制

方式一：同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

说明：

1. 操作共享数据(多线程共同操作的变量)的代码，即为需要被同步的代码
2. 同步监视器：俗称锁，任何一个类的对象，都可以充当锁，要求多个线程必须要共用同一把锁
3. 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的

说明：

1. 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
2. 非静态的同步方法，同步监视器是this，静态的同步方法，同步监视器是当前类本身

方式三：Lock锁

class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                //2.调用锁定方法lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

线程通信

方法	功能
wait()	一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify()	一旦执行次方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就会唤醒优先级高的那个
notifyAll()	一旦执行次方法，就会唤醒所有被wait的线程

说明：

1. 这三个方法必须使用在同步代码块或者同步方法中
2. 这三个方法的调用者必须是同步代码块或同步方法中的同步监视器
3. 这三个方法是定义在java.lang.Object类下

package com.leewle.exer2;
class Clerk{
    private int productNum = 0;
    public synchronized void product() {
       if(productNum < 20){
           productNum++;
           String name = Thread.currentThread().getName();
           System.out.println(name +"生产了第"+productNum+"个产品");
           notify();
       }else{
           try {
               wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
    public synchronized void consumer() {
        if(productNum > 0){
      	    String name = Thread.currentThread().getName();
            System.out.println(name+"消费了第"+productNum+"个产品");
            productNum--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.product();
        }
    }
}
class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumer();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer producer = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);

        producer.start();
        c1.start();
    }
}