java学习--多线程（三）

多线程学习（三）

线程通信

三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的线程，如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
说明：
1.以上三个方法是使用在同步代码块或者同步方法中的，lock锁中有其他方法。
2.以上三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常。

可能的面试题：
sleep()和wait()的异同：
同：一旦执行方法，都会使当前线程进入阻塞状态。
异：1.两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
2.调用的要求不同，sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或者同步方法中。
23.关于是否释放同步监视器，如果两个方法都使用在同步代码块或者同步方法中，sleep()不会释放，wait()会释放。

package exer;

/**
 * 线程通信的应用：例题：生产者/消费者问题
 * 生产者（Productor）将产品交给店员（clerk），而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品，如果生产者试图生产更多的产品，
 * 店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，
 * 如果店中有产品了再通知消费者来取。
 *
 */
class Clerk{
    private int product=0;
    public synchronized void produce()  {
        if(product<20){
            System.out.println(Thread.currentThread().getName()+"开始生产第"+(product+1)+"个产品");
            product++;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    public synchronized void buy(){
        if(product>0){
            System.out.println(Thread.currentThread().getName()+"开始购买，剩余"+product+"个产品");
            product--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}
class Productor extends Thread{
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始生产产品");
        while(true){

            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produce();
        }

    }
}
class Customer extends  Thread{
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始购买产品");
        while(true){

            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.buy();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Productor p1= new Productor(clerk);
        p1.setName("生产者");
        Customer t1=new Customer(clerk);
        t1.setName("消费者");
        p1.start();
        t1.start();
    }



}

多线程的创建（续）

方法三： 实现Callable接口
1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作声明在call()中
3.创建Callable接口的实现类对象
4.将此Callable接口实现类的对象作为参数传递到FutureTask的构造器中
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并且start()。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class NumThread implements Callable{


    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        NumThread numThread= new NumThread();
        FutureTask futureTask=new FutureTask(numThread);
        new Thread(futureTask).start();
        try {
            //get方法返回值是FutureTask构造器参数Callable实现类重写的call()方法返回值
            Object sum=futureTask.get();
            System.out.println("总和为:"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }


}

Callable()接口创建多线程比Runable接口强大之处：
1.call()可以有返回值
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable支持泛型

方法四： 使用线程池
1.提供指定线程数量的线程池
2.执行指定的线程操作，需要提供实现Runable接口或者Callable接口实现类的对象，execute适合Runable，submit适合Callable
3.关闭连接池。

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new NumberThread());
        service.shutdown();
    }
}