Java多线程处理

合集下载

java多线程实际应用案例

java多线程实际应用案例Java多线程是一种并发编程的方式，可以使程序同时执行多个任务，提高程序的执行效率和响应速度。

下面列举了十个Java多线程实际应用案例。

1. 电商网站订单处理：在一个电商网站中，订单的处理是一个非常繁琐且耗时的工作，可以使用多线程实现订单的并发处理，提高订单处理的效率。

2. 聊天软件消息发送：在聊天软件中，用户发送消息是一个频繁的操作，可以使用多线程实现消息的并发发送，提高用户体验。

3. 数据库读写操作：在数据库的读写操作中，读操作可以使用多线程并发执行，提高数据的读取速度；写操作可以使用多线程并发执行，提高数据的写入速度。

4. 图像处理：在图像处理中，可以使用多线程实现图像的并行处理，提高图像处理的速度。

5. 视频编解码：在视频编解码中，可以使用多线程实现视频的并行编解码，提高视频的处理速度。

6. 网络爬虫：在网络爬虫中，可以使用多线程实现并发的爬取网页数据，提高爬虫的效率。

7. 游戏开发：在游戏开发中，可以使用多线程实现游戏的并行处理，提高游戏的运行速度和响应速度。

8. 大数据处理：在大数据处理中，可以使用多线程实现并发的数据处理，提高大数据处理的效率。

9. 并发服务器：在服务器开发中，可以使用多线程实现并发的请求处理，提高服务器的并发能力。

10. 并发任务调度：在任务调度中，可以使用多线程实现并发的任务执行，提高任务的执行效率。

在实际应用中，多线程不仅可以提高程序的执行效率和响应速度，还可以充分利用多核处理器的优势，实现并行计算和并发处理。

然而，多线程编程也面临着诸多挑战，如线程安全、死锁、资源竞争等问题，需要设计合理的线程同步和互斥机制，确保程序的正确性和稳定性。

因此，在使用多线程编程时，需要仔细考虑线程间的依赖关系和数据共享问题，合理规划线程的数量和调度策略，确保多线程程序的正确性和性能。

关于Java多线程处理List数据

关于Java多线程处理List数据⼀、背景多线程数量的问题，⼀般情况下，多线程数量要等于机器CPU核数-1。

⼆、实例1、解决问题：如何让n个线程顺序遍历含有n个元素的List集合import java.util.ArrayList;import java.util.List;import ng3.ArrayUtils;public class Test_4 {/*** 多线程处理list** @param data 数据list* @param threadNum 线程数*/public synchronized void handleList(List<String> data, int threadNum) {int length = data.size();int tl = length % threadNum == 0 ? length / threadNum : (length/ threadNum + 1);for (int i = 0; i < threadNum; i++) {int end = (i + 1) * tl;HandleThread thread = new HandleThread("线程[" + (i + 1) + "] ", data, i * tl, end > length ? length : end);thread.start();}}class HandleThread extends Thread {private String threadName;private List<String> data;private int start;private int end;public HandleThread(String threadName, List<String> data, int start, int end) {this.threadName = threadName;this.data = data;this.start = start;this.end = end;}public void run() {List<String> subList = data.subList(start, end)/*.add("^&*")*/;System.out.println(threadName+"处理了"+subList.size()+"条！");}}public static void main(String[] args) {Test_4 test = new Test_4();// 准备数据List<String> data = new ArrayList<String>();for (int i = 0; i < 6666; i++) {data.add("item" + i);}test.handleList(data, 5);System.out.println(ArrayUtils.toString(data));}}2、List多线程并发读取读取现有的list对象//测试读取List的线程类，⼤概34秒package com.thread.list;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class Main {public static void main(String[] args) {List<String> list = new ArrayList<String>();Map<Long,Integer> map = new HashMap<Long,Integer>();for(int i = 0;i<1000;i++){list.add(""+i);}int pcount = Runtime.getRuntime().availableProcessors();long start = System.currentTimeMillis();for(int i=0;i<pcount;i++){Thread t = new MyThread1(list,map);map.put(t.getId(),Integer.valueOf(i));t.start();try {t.join();} catch (InterruptedException e) {e.printStackTrace();}// System.out.println(list.get(i));}System.out.println("----"+(System.currentTimeMillis() - start));}}//线程类package com.thread.list;import java.util.List;import java.util.Map;public class MyThread1 extends Thread {private List<String> list;private Map<Long,Integer> map;public MyThread1(List<String> list,Map<Long,Integer> map){this.list = list;this.map = map;}@Overridepublic void run() {int pcount = Runtime.getRuntime().availableProcessors();int i = map.get(Thread.currentThread().getId());for(;i<list.size();i+=pcount){System.out.println(list.get(i));}}}3、多线程分段处理List集合场景：⼤数据List集合，需要对List集合中的数据同标准库中数据进⾏对⽐，⽣成新增，更新，取消数据。

JAVA多线程的使用场景与注意事项总结

JAVA多线程的使用场景与注意事项总结Java多线程是指在一个程序中同时运行多个线程，每个线程都有自己的执行代码，但是又共享同一片内存空间和其他系统资源。

多线程的使用场景和注意事项是我们在开发中需要关注的重点，下面将详细进行总结。

一、Java多线程的使用场景：1.提高程序的执行效率：多线程可以充分利用系统资源，将一些耗时的操作放到一个线程中执行，避免阻塞主线程，提高程序的执行效率。

2.实现并行计算：多线程可以将任务拆分成多个子任务，每个子任务分配给一个线程来执行，从而实现并行计算，提高计算速度。

3.响应性能提升：多线程可以提高程序的响应性能，比如在用户界面的开发中，可以使用多线程来处理用户的输入和操作，保证界面的流畅性和及时响应。

4.实时性要求高：多线程可以实现实时性要求高的任务，比如监控系统、实时数据处理等。

5.任务调度与资源管理：多线程可以实现任务的调度和资源的管理，通过线程池可以更好地掌控任务的执行情况和使用系统资源。

二、Java多线程的注意事项：1.线程安全性：多线程操作共享资源时，要注意线程安全问题。

可以通过使用锁、同步方法、同步块等方式来解决线程安全问题。

2.死锁：多线程中存在死锁问题，即多个线程相互等待对方释放资源，导致程序无法继续执行。

要避免死锁问题，应尽量减少同步块的嵌套和锁的使用。

3.内存泄漏：多线程中存在内存泄漏问题，即线程结束后，线程的资源没有得到释放，导致内存占用过高。

要避免内存泄漏问题，应及时释放线程资源。

4.上下文切换：多线程的切换会带来上下文切换的开销，影响程序的执行效率。

要注意合理分配线程的数量，避免过多线程的切换。

5. 线程同步与通信：多线程之间需要进行同步和通信，以保证线程之间的正确协调和数据的一致性。

可以使用synchronized关键字、wait(和notify(方法等方式进行线程同步和通信。

6.线程池的使用：在多线程编程中，可以使用线程池来管理线程的创建和销毁，可以减少线程的创建和销毁的开销，提高程序的性能。

java 多线程feature 用法

Java 多线程特性及用法大纲一. 简介1. 什么是多线程多线程是指在一个程序中同时运行多个线程的并发执行方式。

每个线程都是程序的独立执行单元，它们可以在同一时间内执行不同的任务，使得程序可以更高效地利用多核处理器和资源。

Java是一种支持多线程编程的编程语言，通过其多线程特性，可以实现并发执行不同任务，提高程序的性能和响应能力。

在 Java 中，每个线程都是由 Thread 类或实现了 Runnable 接口的类创建的。

线程可以独立地执行代码，具有自己的程序计数器、栈、寄存器等。

Java提供了多线程编程的支持，使得开发者可以轻松地创建、管理和控制多个线程，以实现并行处理任务，例如同时处理用户输入、后台计算、网络通信等。

2. 为什么使用多线程使用多线程是为了充分利用现代计算机的多核处理器和资源，以提高程序的性能、响应性和效率。

以下是一些使用多线程的主要原因：1. 并行处理：多线程允许程序同时执行多个任务，从而实现并行处理。

这对于需要同时处理多个任务的应用程序非常重要，如图像和视频处理、数据分析等。

2. 提高性能：多线程可以在多核处理器上同时执行不同的任务，从而显著提高应用程序的运行速度和性能。

3. 改善响应性：在单线程应用中，如果一个任务阻塞了，整个程序都会被阻塞。

而多线程允许程序继续响应其他请求，即使某些任务正在等待资源。

4. 任务分解：多线程使得大型任务可以分解成更小的子任务，每个子任务都可以在独立的线程中执行。

这样可以更有效地管理和调度任务。

5. 多任务处理：多线程允许程序同时处理多个任务，比如在一个Web服务器中同时处理多个客户端请求，提供更好的用户体验。

6. 资源共享：多线程允许不同的线程共享同一组资源，如内存、文件、数据库连接等。

这可以减少资源的浪费，并提高资源利用率。

7. 实时性：对于需要实时处理的应用，多线程可以使任务在严格的时间限制内完成，如嵌入式系统、实时图像处理等。

8. 异步编程：多线程可以用于实现异步编程模型，允许程序执行非阻塞的操作，如在网络通信中发送请求同时不阻塞其他操作。

Java的并发编程如何充分利用多核处理器

Java的并发编程如何充分利用多核处理器在当今数字时代，计算机的性能已成为了人们普遍关注的焦点之一。

随着处理器技术的不断革新，多核处理器成为了主流，为软件开发带来了更大的挑战和机遇。

Java作为一门广泛应用于并发编程的语言，也需要充分利用多核处理器的优势，以提高程序的性能和响应能力。

一、多线程编程多线程是Java并发编程的基石，通过同时执行多个线程，利用多核处理器的并行计算能力，可以实现并发执行多个任务，提高系统的吞吐量和并发性能。

开发人员可以通过Java提供的Thread类或者实现Runnable接口来创建线程，并通过控制线程的调度和锁机制来实现线程之间的通信和同步。

二、任务并行化多核处理器的一个重要特点是可以同时执行多个线程，因此，充分利用多核处理器的方法之一就是将任务进行并行化。

任务并行化可以通过拆分一个大任务为多个小任务，并将这些小任务分配给不同的线程来实现。

Java提供了一套Executor框架来支持任务的并行执行，开发人员可以使用ThreadPoolExecutor等类来管理线程池，将任务提交到线程池中执行，框架会自动进行任务的拆分和调度，充分利用多核处理器的性能。

三、数据并行化除了任务级别的并行化之外，充分利用多核处理器的另一个方法是将数据进行并行化。

数据并行化可以通过将大数据集划分为小数据块，并将这些数据块分配给不同的线程来实现。

每个线程独立处理自己负责的数据块，最后将处理结果进行合并。

在Java中，开发人员可以使用Fork/Join框架来实现数据并行化，该框架充分利用了多线程和任务拆分的特性，可以实现高效的并行计算。

四、锁优化在并发编程中，锁是一种重要的同步机制，通过锁可以保证多个线程之间互斥地访问共享资源，避免数据的冲突和不一致。

然而，在多核处理器下，锁可能成为性能瓶颈，因为锁的持有和释放需要涉及到多个核之间的协调和通信。

为了充分利用多核处理器的性能，开发人员可以采用一些锁优化的技术，例如细粒度锁、非阻塞锁、读写锁等，来减少锁的竞争和开销，提高系统的并发性能。

JAVA开发中的多线程编程技术

JAVA开发中的多线程编程技术Java作为一种广泛应用于企业级应用以及各种工业自动化系统的编程语言，其对于处理多线程并发的问题起到了巨大的作用。

在Java开发过程中，我们经常会遇到需要多线程并发处理的情况，比如高并发的Web服务、大数据处理、图像处理等等。

如何正确合理的使用Java多线程技术是一个非常重要的问题。

本文将详细讲解Java开发中的多线程编程技术。

1.了解Java线程模型Java语言具有完善的线程模型，并提供了Thread类以及Runnable接口，方便程序员进行多线程编程。

在进行Java多线程编程的过程中，必须先理解Java的线程模型，包括线程的创建、使用、同步、互斥、线程间通信等。

同时，也要掌握Java虚拟机的内存结构以及线程调度器的工作原理，这些对多线程编程至关重要。

2.使用synchronized实现线程同步在多线程编程中，需要涉及到许多复杂的操作，如多个线程同时对同一共享数据进行读写操作会造成数据不一致等问题。

这时需要使用synchronized关键字来进行同步。

通过对象锁的机制，保证每个时间段只有一个线程能够访问同一个对象的同步代码块。

当线程进入一个对象的同步块时，将获得该对象的锁，只有等线程退出同步块或发生异常时才会释放锁，其他线程才能进入同步块。

通过synchronized关键字的同步机制能控制线程的读写顺序，使多个线程协同工作，防止数据不一致的问题。

3.使用volatile变量实现线程间通信在多线程编程中，需要进行线程间的通信。

在Java语言中，volatile变量可以用来实现线程间的通信。

当一个变量被声明为volatile变量后，所有线程对这个变量的读写操作都会直接在内存中进行，而不会使用线程的缓存中间值。

这样可以避免数据缓存的不一致，并保证在不同线程中读写的顺序是一致的，从而实现了线程之间的通信。

4.掌握并发包中的工具类Java并发包提供了许多实用的工具类，方便程序员在多线程编程中使用。

使用java多线程分批处理数据工具类

使⽤java多线程分批处理数据⼯具类最近由于业务需要，数据量⽐较⼤，需要使⽤多线程来分批处理，提⾼处理效率和能⼒，于是就写了⼀个通⽤的多线程处理⼯具，只需要实现⾃⼰的业务逻辑就可以正常使⽤，现在记录⼀下主要是针对⼤数据量list，将list划分多个线程处理ResultBean类：返回结果统⼀beanpackage mon.model;import java.io.Serializable;import com.alibaba.fastjson.JSON;/*** 返回结果统⼀bean** ResultBean * 创建⼈:wangbeidou * 时间：2018年4⽉12⽇-下午3:49:46 * @version 2.0**/public class ResultBean<T> implements Serializable {private static final long serialVersionUID = 1L;// 成功状态public static final int SUCCESS = 1;// 处理中状态public static final int PROCESSING = 0;// 失败状态public static final int FAIL = -1;// 描述private String msg = "success";// 状态默认成功private int code = SUCCESS;// 备注private String remark;// 返回数据private T data;public ResultBean() {super();}public ResultBean(T data) {super();this.data = data;}/*** 使⽤异常创建结果*/public ResultBean(Throwable e) {super();this.msg = e.toString();this.code = FAIL;}/**** 实例化结果默认成功状态 * ⽅法名：newInstance * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:51:26 * @return ResultBean<T> * @exception * @since 2.0*/public static <T> ResultBean<T> newInstance() {ResultBean<T> instance = new ResultBean<T>();//默认返回信息instance.code = SUCCESS;/**** 实例化结果默认成功状态和数据 * ⽅法名：newInstance * 创建⼈：wangbeidou * 时间：2018年5⽉10⽇-下午2:13:16 * @param data* @return ResultBean<T> * @exception * @since 2.0*/public static <T> ResultBean<T> newInstance(T data) {ResultBean<T> instance = new ResultBean<T>();//默认返回信息instance.code = SUCCESS;instance.msg = "success";instance.data = data;return instance;}/**** 实例化返回结果 * ⽅法名：newInstance * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午4:00:53 * @param code* @param msg* @return ResultBean<T> * @exception * @since 2.0*/public static <T> ResultBean<T> newInstance(int code, String msg) {ResultBean<T> instance = new ResultBean<T>();//默认返回信息instance.code = code;instance.msg = msg;return instance;}/**** 实例化返回结果 * ⽅法名：newInstance * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午4:00:35 * @param code* @param msg* @param data* @return ResultBean<T> * @exception * @since 2.0*/public static <T> ResultBean<T> newInstance(int code, String msg, T data) { ResultBean<T> instance = new ResultBean<T>();//默认返回信息instance.code = code;instance.msg = msg;instance.data = data;return instance;}/**** 设置返回数据 * ⽅法名：setData * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:52:01 * @param data* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> setData(T data){this.data = data;return this;}/**** 设置结果描述 * @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> setMsg(String msg){this.msg = msg;return this;}/**** 设置状态 * ⽅法名：setCode * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午4:17:56 * @param code* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> setCode(int code){this.code = code;return this;}/**** 设置备注) * ⽅法名：setRemark * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午5:47:29 * @param remark* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> setRemark(String remark){this.remark = remark;return this;}/**** 设置成功描述和返回数据 * ⽅法名：success * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:52:58 * @param msg* @param data* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> success(String msg, T data){ this.code = SUCCESS;this.data = data;this.msg = msg;return this;}/**** 设置成功返回结果描述 * ⽅法名：success * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:53:31 * @param msg* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> success(String msg){this.code = SUCCESS;this.msg = msg;return this;}/**** 设置处理中描述和返回数据 * @param data* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> processing(String msg, T data){ this.code = PROCESSING;this.data = data;this.msg = msg;return this;}/**** 设置处理中返回结果描述 * ⽅法名：success * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:53:31 * @param msg* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> processing(String msg){this.code = PROCESSING;this.msg = msg;return this;}/**** 设置失败返回描述和返回数据 * ⽅法名：fail * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:54:04 * @param msg* @param data* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> fail(String msg, T data){this.code = FAIL;this.data = data;this.msg = msg;return this;}/**** 设置失败返回描述 * ⽅法名：fail * 创建⼈：wangbeidou * 时间：2018年4⽉12⽇-下午3:54:32 * @param msg* @return ResultBean<T> * @exception * @since 2.0*/public ResultBean<T> fail(String msg){this.code = FAIL;this.msg = msg;return this;}public T getData() {return data;}public String getMsg() {return msg;}public int getCode() {return code;}public String getRemark() {return remark;}/**** 时间：2018年4⽉12⽇-下午4:42:28 * @return String * @exception * @since 2.0*/public String json(){return JSON.toJSONString(this);}}View CodeITask接⼝：实现⾃⼰的业务package mon.multi.execute;import java.util.Map;/*** 任务处理接⼝* 具体业务逻辑可实现该接⼝* T 返回值类型* E 传⼊值类型* ITask * 创建⼈:wangbeidou * 时间：2018年8⽉4⽇-下午6:12:32 * @version 2.0**/public interface ITask<T, E> {/**** 任务执⾏⽅法接⼝ * ⽅法名：execute * 创建⼈：wangbeidou * 时间：2018年8⽉4⽇-下午6:13:44 * @param e 传⼊对象* @param params 其他辅助参数* @return T 返回值类型* @exception * @since 2.0*/T execute(E e, Map<String, Object> params);}View CodeHandleCallable类：实现Callable接⼝，来处理任务package mon.multi.execute;import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.concurrent.Callable;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import mon.model.ResultBean;/***** HandleCallable * 创建⼈:wangbeidou * 时间：2018年8⽉4⽇-上午11:55:41 ** @version 2.0**/@SuppressWarnings("rawtypes")public class HandleCallable<E> implements Callable<ResultBean> {private static Logger logger = LoggerFactory.getLogger(HandleCallable.class); // 线程名称private String threadName = "";private Map<String, Object> params;// 具体执⾏任务private ITask<ResultBean<String>, E> task;public HandleCallable(String threadName, List<E> data, Map<String, Object> params, ITask<ResultBean<String>, E> task) {this.threadName = threadName;this.data = data;this.params = params;this.task = task;}@Overridepublic ResultBean<List<ResultBean<String>>> call() throws Exception {// 该线程中所有数据处理返回结果ResultBean<List<ResultBean<String>>> resultBean = ResultBean.newInstance();if (data != null && data.size() > 0) {("线程：{},共处理:{}个数据，开始处理......", threadName, data.size());// 返回结果集List<ResultBean<String>> resultList = new ArrayList<>();// 循环处理每个数据for (int i = 0; i < data.size(); i++) {// 需要执⾏的数据E e = data.get(i);// 将数据执⾏结果加⼊到结果集中resultList.add(task.execute(e, params));("线程：{},第{}个数据，处理完成", threadName, (i + 1));}("线程：{},共处理:{}个数据，处理完成......", threadName, data.size()); resultBean.setData(resultList);}return resultBean;}}View CodeMultiThreadUtils类：　多线程⼯具类package mon.multi.execute;import java.util.ArrayList;import java.util.List;import java.util.Map;import pletionService;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorCompletionService;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import mon.model.ResultBean;/***** MultiThreadUtils * 创建⼈:wangbeidou * 时间：2018年8⽉8⽇-下午8:20:42 * @version 2.0**/public class MultiThreadUtils<T> {private static Logger logger = LoggerFactory.getLogger(MultiThreadUtils.class);// 线程个数，如不赋值，默认为5private int threadCount = 5;// 具体业务任务private ITask<ResultBean<String>, T> task;// 线程池管理器private CompletionService<ResultBean> pool = null;/**** 初始化线程池和线程个数 * ⽅法名：newInstance * @return MultiThreadUtils * @exception * @since 2.0*/public static MultiThreadUtils newInstance(int threadCount) {MultiThreadUtils instance = new MultiThreadUtils();threadCount = threadCount;instance.setThreadCount(threadCount);return instance;}/**** 多线程分批执⾏list中的任务 * ⽅法名：execute * 创建⼈：wangbeidou * 时间：2018年8⽉8⽇-下午8:22:31 * @param data 线程处理的⼤数据量list* @param params 处理数据是辅助参数传递* @param task 具体执⾏业务的任务接⼝* @return ResultBean * @exception * @since 2.0*/@SuppressWarnings("rawtypes")public ResultBean execute(List<T> data, Map<String, Object> params, ITask<ResultBean<String>, T> task) { // 创建线程池ExecutorService threadpool = Executors.newFixedThreadPool(threadCount);// 根据线程池初始化线程池管理器pool = new ExecutorCompletionService<ResultBean>(threadpool);// 开始时间（ms）long l = System.currentTimeMillis();// 数据量⼤⼩int length = data.size();// 每个线程处理的数据个数int taskCount = length / threadCount;// 划分每个线程调⽤的数据for (int i = 0; i < threadCount; i++) {// 每个线程任务数据listList<T> subData = null;if (i == (threadCount - 1)) {subData = data.subList(i * taskCount, length);} else {subData = data.subList(i * taskCount, (i + 1) * taskCount);}// 将数据分配给各个线程HandleCallable execute = new HandleCallable<T>(String.valueOf(i), subData, params, task);// 将线程加⼊到线程池pool.submit(execute);}// 总的返回结果集List<ResultBean<String>> result = new ArrayList<>();for (int i = 0; i < threadCount; i++) {// 每个线程处理结果集ResultBean<List<ResultBean<String>>> threadResult;try {threadResult = pool.take().get();result.addAll(threadResult.getData());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}// 关闭线程池threadpool.shutdownNow();// 执⾏结束时间long end_l = System.currentTimeMillis();("总耗时:{}ms", (end_l - l));return ResultBean.newInstance().setData(result);}public int getThreadCount() {return threadCount;}public void setThreadCount(int threadCount) {this.threadCount = threadCount;View Code测试类TestTaskpackage mon.multi.execute;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import mon.model.ResultBean;/**** 具体执⾏业务任务需要实现ITask接⼝在execute中重写业务逻辑* TestTask * 创建⼈:wangbeidou * 时间：2018年8⽉8⽇-下午8:40:32 * @version 2.0**/public class TestTask implements ITask<ResultBean<String>, Integer> {@Overridepublic ResultBean execute(Integer e, Map<String, Object> params) {/*** 具体业务逻辑：将list中的元素加上辅助参数中的数据返回*/int addNum = Integer.valueOf(String.valueOf(params.get("addNum")));e = e + addNum;ResultBean<String> resultBean = ResultBean.newInstance();resultBean.setData(e.toString());return resultBean;}public static void main(String[] args) {// 需要多线程处理的⼤量数据listList<Integer> data = new ArrayList<>(10000);for(int i = 0; i < 10000; i ++){data.add(i + 1);}// 创建多线程处理任务MultiThreadUtils<Integer> threadUtils = MultiThreadUtils.newInstance(5);ITask<ResultBean<String>, Integer> task = new TestTask();// 辅助参数加数Map<String, Object> params = new HashMap<>();params.put("addNum", 4);// 执⾏多线程处理，并返回处理结果ResultBean<List<ResultBean<String>>> resultBean = threadUtils.execute(data, params, task); }}。

JAVA使用多线程（线程池）进行数据处理

JAVA使⽤多线程（线程池）进⾏数据处理*⼯作顺序:* 1)、线程池创建，准备好core数量的核⼼线程，准备接受任务* 1.1、core满了，就将再进来的任务放⼊阻塞队列中。

空闲的core就会⾃⼰去阻塞队列获取任务执⾏* 1.2、阻塞队列满了，就直接开新线程执⾏，最⼤只能开到max指定的数量* 1.3、max满了就⽤RejectedExecut ionHandler拒绝任务* 1.4、max都执⾏完成，有很多空闲.在指定的时间keepAliveTime以后,释放max-core这些线程new LinkedBlockingDeque<>(): 默认是Integer的最⼤值。

内存不够⼀个线程池core 7; max 20，queue:50，100并发进来怎么分配的;7个会⽴即得到执⾏，50个会进⼊队列，再开13个进⾏执⾏。

剩下的30个就使⽤拒绝策略。

Executors . newCachedThreadPool() core是0，所有都可回收Executors . newF ixedThreadPool()固定⼤⼩，core=max; 都不可回收Executors. newScheduledThreadPool()定时任务的线程池Executors. newSingleThreadExecutor()单线程的线程池，后台从队列⾥⾯获取任务，挨个执⾏import mons.collections.CollectionUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.stereotype.Service;import java.util.ArrayList;import java.util.List;import java.util.concurrent.*;/*** 以下是伪代码，要根据⾃⼰的实际逻辑进⾏整合*/@Servicepublic class PushProcessServiceImpl implements PushProcessService {private final static Logger logger = LoggerFactory.getLogger(PushProcessServiceImpl.class);/***每个线程更新的条数* 这表⽰每次执⾏五千条数据的推送操作*/private static final Integer LIMIT = 5000;/*** 起的线程数*/private static final Integer THREAD_NUM = 5;/*** 创建线程池** - corePoolSize：线程核⼼参数选择了5** - maximumPoolSize：最⼤线程数选择了核⼼线程数2倍数** - keepAliveTime：⾮核⼼闲置线程存活时间直接置为0** - unit：⾮核⼼线程保持存活的时间选择了 TimeUnit.SECONDS 秒** - workQueue：线程池等待队列，使⽤容量初始为100的 LinkedBlockingQueue阻塞队列** 线程池拒绝策略，采⽤了默认AbortPolicy：直接丢弃任务，抛出异常。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Runnabel接口
实现多线程的第二种方法是实现Runnable接口。
Runnabel接口位于ng包中，该接口只有一个方法run()，用户定义的类必须实现这个方法。 run()方法是一个比较特殊的方法，它可以被运行系统自动识别并执行。具体来讲，当线程被调度并转入运行状态时，它所执行的就是run()方法。所以，一个实现了Runnable接口的类实际上定义了一个主线程之外的新线程的操作，而定义新线程的操作和执行流程，是实现多线程应用的最主要的工作之一
第10章 Java多线程处理
2010年10月10日
教学目标
对多线程的支持是Java的一大特定，多线程是指在应用程序执行过程中，有多个运行单元可以同时执行。多线程编程使得系统资源并不是由某个执行体独占，而是由多个执行单元共同拥有，轮换使用。正确使用多线程可以消除系统的瓶颈问题，提高整个应用系统的性能。本章将详细介绍Java语言的多线程技术。
Java的多线程
从字面上来解释，多线程就是多个线程的
集合。具体地讲，多线程就是同时执行一个以上的线程，一个线程的执行不必等待另一个线程执行完才执行，所有线程都可以发生在同一时刻。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配在多线程程序中，多个线程共享内存，从而极大地提高了程序的运行效率
教学重点
进程与线程继续Thread类和实现Runnable接口线程优先级线程同步与线程间通信线程组
多线程简介
进程与线程 Java的多线程
进程与线程
进程本身可以看成是系统资源和程序代码的执行位置的集
合。用过UNIX操作系统的读者都知道，在UNIX操作系统中，每个应用程序的执行都在操作系统内核中登记一个进程标志，操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配。每个进程都有自己的内存单元，进程之间是互相独立的，一个进程一般不允许访问其他进程的内存空间，因此，进程间通信非常困难。线程是比进程更小的执行单位。如果将进程概念一分为二，则进程中的系统资源，可以看成是一个静态的对象；而程序代码的执行位置，可以看成一个动态对象，这个动态的部分就是线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，线程之间的通信比较容易解决，从而极大地提高了程序的运行效率
线程同步与线程间通信
同步代码块同步方法线程间通信
同步代码块
若要同步某程序段，可以使用
synchronized(object){}方法，其中object可以是任意的一个对象，{}内的程序语句将被同步化
同步方法
通常，完成一项功能是通过方法来பைடு நூலகம்成的，因此，
在多线程应用中通常将线程中的执行方法设置为同步。在Java系统中，如果将某方法设置为 synchronized，则系统将该方法设置一个内部标记。这个标记可以看成是方法执行的信号灯。如果系统需要调用该方法时，首先检查该信号灯的状态，如果确认该方法不是正在被调用，则首先将信号灯置位，然后调用该方法。当方法执行结束后，将该信号灯复位，以提供给其他线程继续调用该方法
线程间通信
Java是通过Object类的wait、notify、notifyAll这
几个方法来实现线程间通信的，由于所有的类都是从Object继承的，因此在任何类中都可以直接使用这些方法。
wait：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify方法为止。 notify：唤醒同一对象监视器中调用wait的第一个线程。用于类似饭馆有一个空位后通知所有等候就餐的顾客中的第一位可以入座的情况 notifyAll：唤醒同一对象监视器中调用wait的所有线程，具有最高优先级的线程首先被唤醒并执行。用于类似某个不定期的培训班终于招生满额后，通知所有学员都来上课的情况。
线程生命周期
线程调度与优先级
Thread类中有3个和线程优先级有关的成员变量
MAX_PRIORITY、MIN_PRIORITY、 NORMAL_PRIORITY。优先级的概念是线程获得 CPU调度的优先程度。一般的操作系统在进行线程调度时采用如下策略：
优先级高的线程优先获得处理机的控制权，可以在短时间内进入运行状态。优先级低的线程恰恰相反。如果两个或多个线程的优先级相同，则采用FIFO的方法对线程进行排队。
线程组
线程组用来管理一组线程，每个独立的线
程都是线程组的一个成员。一个线程组不仅可以包含多个线程，而且线程组中还可以包含其他线程组。对线程组的启动、挂起、终止操作适用于线程组中的所有线程
本章小结
多线程是Java语言的一个重要概念之一，Java的
许多功能都是使用多线程技术来完成的，读者需要好好掌握这一技术。本章讲述了Java多线程技术，包括多线程概念、通过继承线程类和实现 Runnable接口两种方式分别实现多线程、线程调度与优先级管理、线程同步与线程间通信、线程组等内容。其中线程同步和线程间通信是本章的重点和难点，读者应用心体会本章的所有例程，深刻理解多线程的同步和通信机制。通过本章的学习，读者应掌握Java多线程的编程技巧，学会用多线程技术解决实际问题
守护（Daemon）线程
守护（Daemon）线程是一个在多线程系统中使
用的概念。如果一个线程是Daemon线程，那么当线程运行结束后，只要有另一个用户线程在运行，此线程可以继续运行。在Java中，没有特殊的守护线程类。守护线程只是一类特殊的线程，通过在线程启动之前，调用线程的setDaemon()方法来设置当前线程为守护线程即可。守护线程可以作为支持其他线程的主线程，守护线程体的run()方法通常使用无限循环来等待一个对象或其他线程的申请。当进行申请后，daemon线程就处理它并分配和适的方法
Java线程类与Runnable接口
Thread类 Runnable接口如何在程序中实现多线程
Thread类
当创建了一个Thread类的对象实例后，就
创建了一个新的线程体。JVM通过线程控制句柄，可以启动、终止、暂停线程体的执行。每个线程都是通过派生于Thread类的对象实例中的run()方法来实现线程的执行，因此，由run()方法定义的程序基本运行单元称为线程体
如何在程序中实现多线程
在程序中实现多线程有两种途径：从线程
类继承和实现Runnable接口。无论采用哪种方式，开发人员可以控制的关键性操作有两个：
定义用户线程的操作，即定义用户线程的run() 方法。在适当的时候创建用户线程实例。
线程管理
线程生命周期线程调度与优先级守护（Daemon）线程