java多线程之Callable

最新推荐文章于 2024-07-10 09:58:21 发布
最新推荐文章于 2024-07-10 09:58:21 发布
阅读量1.3k 收藏 2
点赞数 2
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nianbingsihan/article/details/80362072
版权

Callable接口类似于Runnable接口的增强版,call()方法为线程执行体;

call()方法与run方法的区别:

(1)call()方法可以有返回值;

(2)call方法可以声明抛出异常;


Java5开始提供了Future接口来代表Callable接口里call()方法的返回值,并提供了一个FutureTask实现类.

FutureTask还实现了Runnable接口,因此可以作为Thread的target创建线程.


创建并启动有返回值的线程步骤:

(1)创建Callable接口,实现call()方法作为线程执行体.该call()方法有返回值.创建Callable实现类的实例;
(2)使用FutureTask类来包装Callable对象.该FutureTask对象封装了该Callable对象的call()方法的返回值;
(3)使用FutureTask对象作为Thread的对象的target创建并启动新线程;

(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值.

仍然以火车售票系统为例:

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

public class SellTicket {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Ticket tickets = new Ticket(10);
		TicketWindow tw = new TicketWindow(tickets);
		for(int i=1; i<4; i++){
			FutureTask<Void> ft = new FutureTask<Void>(tw);//注意,每个线程都需要new一个新的FutureTask,否则会出现只有一个窗口卖票
			Thread t = new Thread(ft,"TickWindow-" + i);
			t.start();
		}
	}
}

class TicketWindow implements Callable<Void>{
	//private int tickets = 10;//车票总量
	
	private Ticket tickets;
	
	public TicketWindow(Ticket tickets){
		this.tickets = tickets;
	}
	
	@Override
	public Void call(){
		while(true){
			synchronized (tickets) {
				int currentNo = tickets.getNum();
				if(currentNo>0){
					System.out.println(Thread.currentThread().getName() + "准备出票,剩余票数:" + currentNo + "张");
					--currentNo;
					tickets.setNum(currentNo);                                                                                              
	                System.out.println(Thread.currentThread().getName() + "卖出一张,剩余票数:" + currentNo + "张");
	                try {
						Thread.sleep(500);//出票成功后让当前售票窗口睡眠,以便让其他售票窗口卖票
						
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
	                //Thread.yield();
				}
				else{
					System.out.println(Thread.currentThread().getName() + "余票不足,停止售票!");
					break;
				}
			}	
		}
		return null;
	}
}

class Ticket{
	private int num;
	public Ticket(int n){
		this.num = n;
	}
	public void setNum(int n){
		this.num = n;
	}
	public int getNum(){
		return num;
	}
}

输出:

TickWindow-1准备出票,剩余票数:10张
TickWindow-1卖出一张,剩余票数:9张
TickWindow-3准备出票,剩余票数:9张
TickWindow-3卖出一张,剩余票数:8张
TickWindow-3准备出票,剩余票数:8张
TickWindow-3卖出一张,剩余票数:7张
TickWindow-3准备出票,剩余票数:7张
TickWindow-3卖出一张,剩余票数:6张
TickWindow-3准备出票,剩余票数:6张
TickWindow-3卖出一张,剩余票数:5张
TickWindow-3准备出票,剩余票数:5张
TickWindow-3卖出一张,剩余票数:4张
TickWindow-3准备出票,剩余票数:4张
TickWindow-3卖出一张,剩余票数:3张
TickWindow-2准备出票,剩余票数:3张
TickWindow-2卖出一张,剩余票数:2张
TickWindow-2准备出票,剩余票数:2张
TickWindow-2卖出一张,剩余票数:1张
TickWindow-2准备出票,剩余票数:1张
TickWindow-2卖出一张,剩余票数:0张
TickWindow-2余票不足,停止售票!
TickWindow-3余票不足,停止售票!
TickWindow-1余票不足,停止售票!

对于实现了Callable接口的多线程类,还可以利用线程池方式提交任务.

主要步骤如下,

(1)通过Executors.newFixedThreadPool(int nThreads)等方法创建线程池对象;

(2)创建Callable接口的实现类,作为线程池对象的submit提交对象;

(3)使用Future对象来获得Callable对象的call()方法的返回值;

ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
someClassImplimentCallable someClass = new someClassImplimentCallable();
Future<T> future = executorService.submit(someClass);

这种方式模拟的火车售票系统如下:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class SellTicket {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Ticket tickets = new Ticket(10);
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		for(int i=1; i<4; i++){
			TicketWindow tw = new TicketWindow(tickets);
			Future<Void> future = executorService.submit(tw);
		}
		executorService.shutdown();
	}
}

class TicketWindow implements Callable<Void>{
	//private int tickets = 10;//车票总量
	
	private Ticket tickets;
	
	public TicketWindow(Ticket tickets){
		this.tickets = tickets;
	}
	
	@Override
	public Void call(){
		while(true){
			synchronized (tickets) {
				int currentNo = tickets.getNum();
				if(currentNo>0){
					System.out.println(Thread.currentThread().getName() + "准备出票,剩余票数:" + currentNo + "张");
					--currentNo;
					tickets.setNum(currentNo);                                                                                              
	                System.out.println(Thread.currentThread().getName() + "卖出一张,剩余票数:" + currentNo + "张");
	                try {
						Thread.sleep(500);//出票成功后让当前售票窗口睡眠,以便让其他售票窗口卖票
						
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
	                //Thread.yield();
				}
				else{
					System.out.println(Thread.currentThread().getName() + "余票不足,停止售票!");
					break;
				}
			}	
		}
		return null;
	}
}

class Ticket{
	private int num;
	public Ticket(int n){
		this.num = n;
	}
	public void setNum(int n){
		this.num = n;
	}
	public int getNum(){
		return num;
	}
}


Java5开始通过显式定义同步锁对象来实现同步-Lock对象

接口Lock互斥锁ReadWriteLock 读写锁
实现类ReentrantLock 可重入锁ReentrantReadWriteLock
JDK8新增 StampedLock

ReentrantLock较为常用,格式如下:

class Example{
	//定义锁对象
	private final ReentrantLock lock = new ReentrantLock();
	//定义需要保证线程安全的方法
	public void function(){
		//加锁
		lock.lock();
		try{
			//需要保证线程安全的代码;
		}finally{
			lock.unlock();
		}
	}
}

使用同步锁实现的多线程模拟火车售票系统:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.ReentrantLock;


public class SellTicket {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//方法1,创建Thread子类进行提交,结果是一个窗口卖票?
		Ticket tickets = new Ticket(10);
		TicketWindow tw = new TicketWindow(tickets);
		for(int i=1; i<4; i++){
			FutureTask<Void> ft = new FutureTask<Void>(tw);
			Thread t = new Thread(ft,"TickWindow-" + i);
			t.start();
		}
	}
}

class TicketWindow implements Callable<Void>{
	//private int tickets = 10;//车票总量
	
	private Ticket tickets;
	
	private final ReentrantLock lock = new ReentrantLock();
	
	public TicketWindow(Ticket tickets){
		this.tickets = tickets;
	}
	
	@Override
	public Void call(){
		while(true){
			lock.lock();
			try{
				int currentNo = tickets.getNum();
				if(currentNo>0){
					System.out.println(Thread.currentThread().getName() + "准备出票,剩余票数:" + currentNo + "张");
					--currentNo;
					tickets.setNum(currentNo);                                                                                              
	                System.out.println(Thread.currentThread().getName() + "卖出一张,剩余票数:" + currentNo + "张");
	                try {
						Thread.sleep(500);//出票成功后让当前售票窗口睡眠,以便让其他售票窗口卖票
						
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				else{
					System.out.println(Thread.currentThread().getName() + "余票不足,停止售票!");
					break;
				}
			}finally{
				lock.unlock();
			}
		}
		return null;
	}
}

class Ticket{
	private int num;
	public Ticket(int n){
		this.num = n;
	}
	public void setNum(int n){
		this.num = n;
	}
	public int getNum(){
		return num;
	}
}


本文参考:

https://blog.csdn.net/pengych_321/article/details/50664749

https://my.oschina.net/u/566591/blog/1576410

http://blog.cnsyear.com/2018/03/12/1520865594911.html

https://www.cnblogs.com/dolphin0520/p/3949310.html

http://www.cnblogs.com/felixzh/p/6036074.html


nianbingsihan
关注
专栏目录
java callable（多线程）
02-16
callable用法
JAVA多线程—Callable详解
热门推荐
m0_61160520的博客
07-10 1万+
Callable作为除Thread和Runnable外第三种线程创建方式， - Callable提高响应速度（减少了创建新线程的时间） - Callable降低资源消耗（重复利用线程池中线程，不需要每次都创建） - Callable便于线程管理
【转】-多线程之Callable
最新发布
booleandev
07-10 671
而自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。在前面的文章中我们讲述了创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。
java中Callable实现多线程
gb4215287的博客
06-19 632
java中Callable实现多线程
Java Callable用法
Levin的专栏
11-18 1670
Java Thread ExecutorService Callable Runnable  Callable 和 Runnable 的使用方法大同小异， 区别在于：  1.Callable 使用 call（） 方法， Runnable 使用 run() 方法  2.call() 可以返回值， 而 run()方法不能返回。  3.call() 可以抛出受检查的异常，比如Clas
Java多线程 Callable和Future
烟雨gps
03-01 279
Java多线程 Callable和Future 文章目录Java多线程 Callable和Future1、简介2、使用 1、简介 （1）先来了解一下Callable 接口 Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。Callable接口的定义如下： public interface Callable<V&g...
Java多线程之Callable接口的实现
08-27
Java多线程之Callable接口的实现 Java中的多线程编程是指在一个程序中同时运行多个线程，以提高程序的执行效率和响应速度。在Java中，有两种方式可以实现多线程编程，即继承Thread类和实现Runnable接口。然而，在...
Java多线程实现Callable接口
09-02
通过以上知识点，我们可以看到Callable接口在Java多线程中的应用，它可以方便地处理返回值，并且与ExecutorService结合，提供了强大的并发处理能力。在实际开发中，特别是在大数据处理、计算密集型任务等场景下，...
Java多线程Callable接口
01-20
在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它。 import java.util.ArrayList; import java.util....
Java多线程Callable和Future接口区别
08-19
"Java多线程Callable和Future接口区别" Java多线程Callable和Future接口是Java语言中两个非常重要的接口，它们都是Java多线程编程中使用的接口，用于描述异步计算的结果。在JavaSE5中引入的Callable是一个具有类型...
Callable接口、Runable接口、Future接口
weixin_34133829的博客
11-08 1622
1. Callable与Runable区别 Java从发布的第一个版本开始就可以很方便地编写多线程的应用程序，并在设计中引入异步处理。Thread类、Runnable接口和Java内存管理模型使得多线程编程简单直接。 但Thread类和Runnable接口都不允许声明检查型异常，也不能定义返回值。没有返回值这点稍微有点麻烦。不能声明抛出检查型异常则更麻烦一些。 public void run()方...
java 多线程callable_使用Callable实现多线程
weixin_39883705的博客
02-16 240
package cn.jd.thread;import java.io.File;import java.io.IOException;import java.net.MalformedURLException;import java.net.URL;import org.apache.commons.io.FileUtils;/** 下载图片*/public class WebDownloade...
Java线程 (使用Callable实现多线程)，看完你发现多线程多么简单！（二）
探索技术与实践的旅程，分享编程经验与工具使用心得，助力开发者提升技能。
04-22 684
1.Thread 与 Runnable 的关系     经过一系列的分析之后可以发现，在多线程的实现过程之中已经有了两种做法：Thread类、Runnable接口，如果从代码结构本身来讲，使用Runnable是最方便的，因为其可以避免单继承的局限，同时也可以更好的进行功能的扩充。     但是从结构上也需要来观察Thread与Runnable的联系，打开Thread类的定义： public class Thread extend
java_多线程Callable
xixihaha_coder的博客
06-16 118
实现Callable接口(了解即可) 1.实现Callable接口，需要返回值类型 2.重写call方法，需要抛出异常 3.创建目标对象 4.创建执行服务：ExecutorService =serExecutors.newFixedThreadPool(1); 5.提交执行 Future r1=ser.submit(t1); 6.获取结果：boolean rs1=r1.get(); 7.关闭服务: ser.shutdown(); 代码演示 package com.test1; import java.i
Java多线程Callable
qq_42900213的博客
11-17 331
Callable可以有返回值，返回值通过 Future 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
Java 多线程之实现Callable
猪在黑魔纹里
04-19 1094
实现Callable为JDK5新增功能，和实现Runnable相比，借助FutureTask类可以实现更加强大的功能，使用起来更加灵活： 相比run方法，call方法可以有返回值。 方法可以抛出异常。 支持泛型的返回值。 演示示例： class MyThread implements Callable { @override public Object call() throws Exception { 业务代码 return xxx; } } public static void m
java 实现Callable 多线程
longum的博客
08-22 2464
Java多线程，实现Callable 多线程完成处理List分段数据
java多线程实现callable接口
05-13
在这个方法中，我们可以编写我们的多线程代码，并且使用return语句返回一个结果。 然后，我们可以在主线程中使用Callable创建一个Future对象，以便在后面获取线程的结果。下面是一个使用Future的例子： ```java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值