Java多线程（三）
目录
五、线程的通信
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），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。
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 类，比如获取返回结果。
-
Future 接口：
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutrueTask 是 Futrue 接口的唯一的实现类。
- FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。
6.2 多线程的创建方式之四：使用线程池
-
线程池的引入：
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。
-
线程池的思路：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
-
使用线程池的好处：
-
提高响应速度（减少了创建新线程的时间）
-
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
-
便于线程管理
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 的对象，调用该实现类的方法进行设置。
-
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
service1.setCorePoolSize(15);
service1.setKeepAliveTime();
声明：本站所发布的一切破解补丁、注册机和注册信息及软件的解密分析文章仅限用于学习和研究目的；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络，版权争议与本站无关。您必须在下载后的24个小时之内，从您的电脑中彻底删除上述内容。如果您喜欢该程序，请支持正版软件，购买注册，得到更好的正版服务。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
