Java多线程(三)()

Java多线程(三)

  • Java多线程(三)五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题
  • 5.1 wait() 与 notify() 和 notifyAll() 介绍:
  • 5.2 wait() 的使用:
  • 5.3 notify() / notifyAll() 的使用
  • 5.4 经典例题:生产者/消费者问题
  • 六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 6.1 多线程的创建方式之三:实现Callable接口
  • 6.2 多线程的创建方式之四:使用线程池

五、线程的通信

5.1 wait() 与 notify() 和 notifyAll() 介绍:

  • wait():令当前线程挂起并放弃CPU、同步资源并等待,使别的线程可访问并修改共享资源,而当前线程排队等候其他线程调用notify() 或 notifyAll() 方法唤醒,唤醒后等待重新获得对监视器的所有权后才能继续执行。
  • notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
  • notifyAll ():唤醒正在排队等待资源的所有线程结束等待。
  • 这三个方法只有在 synchronized 方法 或 synchronized 代码块中才能使用,否则会报 java.lang.IllegalMonitorStateException异常。
  • 因为这三个方法必须有锁对象调用,而任意对象都可以作为 synchronized 的同步锁, 因此这三个方法只能在Object类中声明。

5.2 wait() 的使用:

  • 在当前线程中调用方法: 对象名.wait() 。
  • 使当前线程进入等待(某对象)状态 ,直到另一线程对该对象发出 notify (或notifyAll) 为止。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。
  • 调用此方法后,当前线程将释放对象监控权 ,然后进入等待。
  • 在当前线程被 notify 后,要重新获得监控权,然后从断点处继续代码的执行。

5.3 notify() / notifyAll() 的使用

  • 在当前线程中调用方法: 对象名.notify()。
  • 功能:唤醒等待该对象监控权的一个/所有线程。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。

5.4 经典例题:生产者/消费者问题

题目描述:
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如 果店中有产品了再通知消费者来取走产品。

题目描述:

生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如 果店中有产品了再通知消费者来取走产品。

class Clerk{

    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {

        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            
            notify();

        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            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() {
        System.out.println(getName() + ":开始生产产品.....");

        while(true){
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");

        while(true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

六、JDK5.0新增多线程创建方式

6.1 多线程的创建方式之三:实现Callable接口

  • 创建一个实现 Callable 的实现类
  • 实现call方法,将此线程需要执行的操作声明在call() 中。
  • 创建 Callable 接口实现类的对象。
  • 将此 Callable 接口实现类的对象作为传递到 FutureTask 构造器中,创建 FutureTask 的对象。
  • 将 FutureTask 的对象作为参数传递到 Thread 类的构造器中,创建 Thread 对象,并调用 start() 。
  • 获取 Callable 中 call 方法的返回值。(可选)
//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();
        }
    }
}
  • 与使用 Runnable 相比, Callable功能更强大些:

    相比run()方法,可以有返回值。
    方法可以抛出异常。
    支持泛型的返回值。
    需要借助 FutureTask 类,比如获取返回结果。

  • 相比run()方法,可以有返回值。
  • 方法可以抛出异常。
  • 支持泛型的返回值。
  • 需要借助 FutureTask 类,比如获取返回结果。
  • Future 接口:

    可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    FutrueTask 是 Futrue 接口的唯一的实现类。
    FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值。

  • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
  • FutrueTask 是 Futrue 接口的唯一的实现类。
  • FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值。

6.2 多线程的创建方式之四:使用线程池

  • 线程池的引入:
    经常创建和销毁、使用量特别大的资源,比如并发情况下的线程, 对性能影响很大。
  • 线程池的思路:
    提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
  • 使用线程池的好处:

    提高响应速度(减少了创建新线程的时间)

    降低资源消耗(重复利用线程池中线程,不需要每次都创建)

    便于线程管理
    corePoolSize:核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理
    corePoolSize:核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止
  • 线程池的使用:

(1)提供指定线程数量的线程池。

(2)执行指定的线程的操作,需要提供实现 Runnable 接口或 Callable 接口实现类的对象。

(3)关闭连接池。

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);
            }
        }
    }
}

class NumberThread1 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);
      
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
//        service.submit(Callable callable);//适合使用于Callable
        
        //3.关闭连接池
        service.shutdown();
    }
}
  • 线程池相关API
  • JDK 5.0 起提供了线程池相关API:ExecutorService 和 Executors 。
  • ExecutorService:真正的线程池接口。常见子类 ThreadPoolExecutor。
//	执行任务/命令,没有返回值,一般用来执行 Runnable
	void execute(Runnable command)
        
//	执行任务,有返回值,一般又来执行 Callable
    Future submit(Callable task)

//	关闭连接池
    void shutdown()
  • Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池。
//	创建一个可根据需要创建新线程的线程池
	Executors.newCachedThreadPool()
        
//	创建一个可重用固定线程数的线程池        
	Executors.newFixedThreadPool(n)
        
//	创建一个只有一个线程的线程池          
    Executors.newSingleThreadExecutor() 
        
//	创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。 
	Executors.newScheduledThreadPool(n)
  • 线程池的属性设置

    ExecutorService 是一个接口,里面并没有设置线程池属性的方法,故不能用该接口的对象来对线程池进行属性设置。

    设置线程池属性需要通过创建 ExecutorService 接口的实现类 ThreadPoolExecutor 的对象,调用该实现类的方法进行设置。

  • ExecutorService 是一个接口,里面并没有设置线程池属性的方法,故不能用该接口的对象来对线程池进行属性设置。
  • 设置线程池属性需要通过创建 ExecutorService 接口的实现类 ThreadPoolExecutor 的对象,调用该实现类的方法进行设置。
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
        service1.setCorePoolSize(15);
        service1.setKeepAliveTime();
————————

Java多线程(三)

  • Java多线程(三)五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 五、线程的通信5.1 wait() 与 notify() 和 notifyAll() 介绍:5.2 wait() 的使用:5.3 notify() / notifyAll() 的使用5.4 经典例题:生产者/消费者问题
  • 5.1 wait() 与 notify() 和 notifyAll() 介绍:
  • 5.2 wait() 的使用:
  • 5.3 notify() / notifyAll() 的使用
  • 5.4 经典例题:生产者/消费者问题
  • 六、JDK5.0新增多线程创建方式6.1 多线程的创建方式之三:实现Callable接口6.2 多线程的创建方式之四:使用线程池
  • 6.1 多线程的创建方式之三:实现Callable接口
  • 6.2 多线程的创建方式之四:使用线程池

五、线程的通信

5.1 wait() 与 notify() 和 notifyAll() 介绍:

  • wait():令当前线程挂起并放弃CPU、同步资源并等待,使别的线程可访问并修改共享资源,而当前线程排队等候其他线程调用notify() 或 notifyAll() 方法唤醒,唤醒后等待重新获得对监视器的所有权后才能继续执行。
  • notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
  • notifyAll ():唤醒正在排队等待资源的所有线程结束等待。
  • 这三个方法只有在 synchronized 方法 或 synchronized 代码块中才能使用,否则会报 java.lang.IllegalMonitorStateException异常。
  • 因为这三个方法必须有锁对象调用,而任意对象都可以作为 synchronized 的同步锁, 因此这三个方法只能在Object类中声明。

5.2 wait() 的使用:

  • 在当前线程中调用方法: 对象名.wait() 。
  • 使当前线程进入等待(某对象)状态 ,直到另一线程对该对象发出 notify (或notifyAll) 为止。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。
  • 调用此方法后,当前线程将释放对象监控权 ,然后进入等待。
  • 在当前线程被 notify 后,要重新获得监控权,然后从断点处继续代码的执行。

5.3 notify() / notifyAll() 的使用

  • 在当前线程中调用方法: 对象名.notify()。
  • 功能:唤醒等待该对象监控权的一个/所有线程。
  • 调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)。

5.4 经典例题:生产者/消费者问题

题目描述:
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如 果店中有产品了再通知消费者来取走产品。

题目描述:

生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如 果店中有产品了再通知消费者来取走产品。

class Clerk{

    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {

        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            
            notify();

        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            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() {
        System.out.println(getName() + ":开始生产产品.....");

        while(true){
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");

        while(true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

六、JDK5.0新增多线程创建方式

6.1 多线程的创建方式之三:实现Callable接口

  • 创建一个实现 Callable 的实现类
  • 实现call方法,将此线程需要执行的操作声明在call() 中。
  • 创建 Callable 接口实现类的对象。
  • 将此 Callable 接口实现类的对象作为传递到 FutureTask 构造器中,创建 FutureTask 的对象。
  • 将 FutureTask 的对象作为参数传递到 Thread 类的构造器中,创建 Thread 对象,并调用 start() 。
  • 获取 Callable 中 call 方法的返回值。(可选)
//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();
        }
    }
}
  • 与使用 Runnable 相比, Callable功能更强大些:

    相比run()方法,可以有返回值。
    方法可以抛出异常。
    支持泛型的返回值。
    需要借助 FutureTask 类,比如获取返回结果。

  • 相比run()方法,可以有返回值。
  • 方法可以抛出异常。
  • 支持泛型的返回值。
  • 需要借助 FutureTask 类,比如获取返回结果。
  • Future 接口:

    可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    FutrueTask 是 Futrue 接口的唯一的实现类。
    FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值。

  • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
  • FutrueTask 是 Futrue 接口的唯一的实现类。
  • FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值。

6.2 多线程的创建方式之四:使用线程池

  • 线程池的引入:
    经常创建和销毁、使用量特别大的资源,比如并发情况下的线程, 对性能影响很大。
  • 线程池的思路:
    提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。
  • 使用线程池的好处:

    提高响应速度(减少了创建新线程的时间)

    降低资源消耗(重复利用线程池中线程,不需要每次都创建)

    便于线程管理
    corePoolSize:核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理
    corePoolSize:核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止
  • 线程池的使用:

(1)提供指定线程数量的线程池。

(2)执行指定的线程的操作,需要提供实现 Runnable 接口或 Callable 接口实现类的对象。

(3)关闭连接池。

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);
            }
        }
    }
}

class NumberThread1 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);
      
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
//        service.submit(Callable callable);//适合使用于Callable
        
        //3.关闭连接池
        service.shutdown();
    }
}
  • 线程池相关API
  • JDK 5.0 起提供了线程池相关API:ExecutorService 和 Executors 。
  • ExecutorService:真正的线程池接口。常见子类 ThreadPoolExecutor。
//	执行任务/命令,没有返回值,一般用来执行 Runnable
	void execute(Runnable command)
        
//	执行任务,有返回值,一般又来执行 Callable
    Future submit(Callable task)

//	关闭连接池
    void shutdown()
  • Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池。
//	创建一个可根据需要创建新线程的线程池
	Executors.newCachedThreadPool()
        
//	创建一个可重用固定线程数的线程池        
	Executors.newFixedThreadPool(n)
        
//	创建一个只有一个线程的线程池          
    Executors.newSingleThreadExecutor() 
        
//	创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。 
	Executors.newScheduledThreadPool(n)
  • 线程池的属性设置

    ExecutorService 是一个接口,里面并没有设置线程池属性的方法,故不能用该接口的对象来对线程池进行属性设置。

    设置线程池属性需要通过创建 ExecutorService 接口的实现类 ThreadPoolExecutor 的对象,调用该实现类的方法进行设置。

  • ExecutorService 是一个接口,里面并没有设置线程池属性的方法,故不能用该接口的对象来对线程池进行属性设置。
  • 设置线程池属性需要通过创建 ExecutorService 接口的实现类 ThreadPoolExecutor 的对象,调用该实现类的方法进行设置。
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
        service1.setCorePoolSize(15);
        service1.setKeepAliveTime();