java多线程工具

① 《java多线程编程实战指南（核心篇）》epub下载在线阅读，求百度网盘云资源

《Java多线程编程实战指南（核心篇）》（黄文海）电子书网盘下载免费在线阅读

资源链接：

链接：https://pan..com/s/1ZuTI8tfjbzyOip5krhPxqg

书名：Java多线程编程实战指南（核心篇）

作者：黄文海

豆瓣评分：9.0

出版社：电子工业出版社

出版年份：2017-4

页数：480

内容简介：随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了——如今就连智能手机这样的消费类设备都已配备了4核乃至8核的处理器，更何况商用系统！在此背景下，以往靠单个处理器自身处理能力的提升所带来的软件计算性能提升的那种“免费午餐”已不复存在，这使得多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。故而，掌握多线程编程技能对广大开发人员的重要性亦由此可见一斑。《Java多线程编程实战指南（核心篇）》以基本概念、原理与方法为主线，辅以丰富的实战案例和生活化实例，并从Java虚拟机、操作系统和硬件多个层次与角度出发，循序渐进、系统地介绍Java平台下的多线程编程核心技术及相关工具。

《Java多线程编程实战指南（核心篇）》适合有一定Java语言基础的读者作为入门多线程编程之用，也适合有一定多线程编程经验的读者作为重新梳理知识结构以提升认知层次和参考之用。

② java 多线程

所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。
线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。
Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。
Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。

class ThreadTest{
public static void main(String args[]){
Thread t = Thread.currentThread();
t.setName("单线程"); //对线程取名为"单线程"
t.setPriority(8);
//设置线程优先级为8，最高为10，最低为1，默认为5
System.out.println("The running thread: " + t);
// 显示线程信息
try{
for(int i=0;i<3;i++){
System.out.println("Sleep time " + i);
Thread.sleep(100); // 睡眠100毫秒
}
}catch(InterruptedException e){// 捕获异常
System.out.println("thread has wrong");
}
}
}

多线程的实现方法
继承Thread类
可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。
在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
public class ThreadSubclassName extends Thread{
public ThreadSubclassName(){
..... // 编写子类的构造方法，可缺省
}
public void run(){
..... // 编写自己的线程代码
}
}
用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:
ThreadSubclassName ThreadObject =
new ThreadSubclassName();
然后，就可启动该线程对象表示的线程：
ThreadObject.start(); //启动线程

应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。
class ThreadDemo extends Thread{
private String whoami;
private int delay;
public ThreadDemo(String s,int d){
whoami=s;
delay=d;
}
public void run(){
try{
sleep(delay);
}catch(InterruptedException e)
System.out.println("Hello World!" + whoami
+ " " + delay);
}
}
public class MultiThread{
public static void main(String args[]){
ThreadDemo t1,t2,t3;
t1 = new ThreadDemo("Thread1",
(int)(Math.random()*2000));
t2 = new ThreadDemo("Thread2",
(int)(Math.random()*2000));
t3 = new ThreadDemo("Thread3",
(int)(Math.random()*2000));
t1.start();
t2.start();
t3.start();
}
}

实现Runnable接口
编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。
创建线程对象可用下面的两个步骤来完成:
(1)生成Runnable类ClassName的对象
ClassName RunnableObject = new ClassName();
(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。
Thread ThreadObject = new Thread(RunnableObject);
然后，就可启动线程对象ThreadObject表示的线程：
ThreadObject.start();
在Thread类中带有Runnable接口的构造方法有:
public Thread(Runnable target);
public Thread(Runnable target, String name);
public Thread(String name);
public Thread(ThreadGroup group，Runnable target);
public Thread(ThreadGroup group，Runnable target，
String name);
其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。
用Runnable接口实现的多线程。
class TwoThread implements Runnable{
TwoThread(){
Thread t1 = Thread.currentThread();
t1.setName("第一主线程");
System.out.println("正在运行的线程: " + t1);
Thread t2 = new Thread(this,"第二线程");
System.out.println("创建第二线程");
t2.start();
try{
System.out.println("第一线程休眠");
Thread.sleep(3000);
}catch(InterruptedException e){
System.out.println("第一线程有错");
}
System.out.println("第一线程退出");
}
public void run(){
try{
for(int i = 0;i < 5;i++){
System.out.println(“第二线程的休眠时间：”
+ i);
Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println("线程有错");
}
System.out.println("第二线程退出");
}
public static void main(String args[]){
new TwoThread();
}
}
程序运行结果如下：
正在运行的线程: Thread[第一主线程,5,main
创建第二线程
第一线程休眠
第二线程的休眠时间：0
第二线程的休眠时间：1
第二线程的休眠时间：2
第一线程退出
第二线程的休眠时间：3
第二线程的休眠时间：4
第二线程退出
另外,虚机团上产品团购,超级便宜

③ java多线程(断点)下载

起始位置+已下载的字节数

④ java如何实现基于http和ftp多线程下载工具...

要访问网络资源就要去了解你要访问的网络资源所使用的协议。一般来说我们所使用的协议都是公开式的协议，比如http协议，它在数据的前面部分先设置一些信息来说明它所发送的数据的大小，文件类型等等。而多线程的实现原理就是先从http协议中获取要下载的资源的资源大小，然后再分多个线程从不同的起点跟终点来分段下载资源。ftp资源的道理也是一样。当然我并不是网络方面的专家，对网络我也不懂。以后只是我个人见解。
以下是给你找的一个java实现的http多线程下载。你看看吧
http://shazi.javaeye.com/blog/99132

⑤ 什么是JAVA的多线程

简单,先回答什么是线程:即程序的执行路径,再回答多线程:多线程就是一个程序中有多条不同的执行路径

JAVA多线程的优点:可以并发的执行多项任务,比如说你浏览网页的同时还可以听歌

⑥ 在Java 中多线程的实现方法有哪些，如何使用

1、 认识Thread和Runnable

Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例，之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结：Thread和Runnable是实现java多线程的2种方式，runable是接口，thread是类，建议使用runable实现java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。

2、 认识Thread的start和run

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3、 线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：

1） 线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

2） 当该对象调用了start()方法，就进入可运行状态；

3） 进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

4） 进入运行状态后case就比较多，大致有如下情形：

·run()方法或main()方法结束后，线程就进入终止状态；

·当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

·当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

·当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的stop。

⑦ 求java多线程下载工具的源程序！

java实现多线程可以继承Thread类，也可以通过实现Runnable接口实现。下面是以池塘放水演示多线程的例子：

package Thread;
class Water{//水塘类
static Object water=new Object();
static int total=6;//假设水塘总共可以含水量为6
static int mqsl=3;//假设水塘中拥有含水量为3
static int ps=0;//假设水塘目前排水量为0
}
class ThreadA extends Thread{//排水类
void pswork(){
synchronized(Water.water){
System.out.println("水塘是否没有水： "+isEmpty());
if(isEmpty()){
try{
Water.water.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
else{
Water.ps++;
System.out.println("水塘目前排水水量 "+Water.ps);
}
//System.out.println("Water.ps"+Water.ps);
}
}
public void run(){
while(Water.mqsl<Water.total){
if(isEmpty())
System.out.println("水塘目前没有水,排水线程被挂起");
System.out.println("排水工作开始");
pswork();
try{
sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}

}
}
public boolean isEmpty(){
return Water.mqsl==Water.ps?true:false;
}
}
class ThreadB extends Thread{//进水类
void jswork(){
synchronized(Water.water){
Water.mqsl++;//假设水塘每小时进水量为1
Water.water.notify();
System.out.println("水塘目前进水量为 "+Water.mqsl);
}
}
public void run(){
while(Water.mqsl<Water.total){
System.out.println("进水工作开始");
jswork();
try{
sleep(3000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}

}
public class PoolPattern {
public static void main(String[] args) {
// TODO 自动生成方法存根
ThreadA threadA=new ThreadA();
ThreadB threadB=new ThreadB();
threadB.start();
threadA.start();
}

}
运行结果：
进水工作开始
排水工作开始
水塘目前进水量为 4
水塘是否没有水： false
水塘目前排水水量 1
排水工作开始
水塘是否没有水： false
水塘目前排水水量 2
排水工作开始
水塘是否没有水： false
水塘目前排水水量 3
进水工作开始
水塘目前进水量为 5
排水工作开始
水塘是否没有水： false
水塘目前排水水量 4
排水工作开始
水塘是否没有水： false
水塘目前排水水量 5
水塘目前没有水,排水线程被挂起
排水工作开始
水塘是否没有水： true
进水工作开始
水塘目前进水量为 6

⑧ java 有没有比threadpooltaskexecutor更好的多线程工具类

使用SPRING中的线程池ThreadPoolTaskExecutor实现并发。

一：不需要返回值的情况
1，初始化线程池
Java代码
ThreadPoolTaskExecutor poolTaskExecutor = new ThreadPoolTaskExecutor();
poolTaskExecutor.setQueueCapacity(10000);
poolTaskExecutor.setCorePoolSize(5);
poolTaskExecutor.setMaxPoolSize(10);
poolTaskExecutor.setKeepAliveSeconds(5000);
poolTaskExecutor.initialize();

2，在线程池中执行某个线程
Java代码
poolTaskExecutor.execute(new Thread(Objct...){...});

二：需要返回值的情况
1，初始化线程池poolTaskExecutor，同上

2，新建一个类，实现Callable接口
Java代码
class GetFromDB implements Callable<User> {
private UserDao userDao;
private Long userId;

public GetFromDB(UserDao userDao, Long userId) {
this.userDao = userDao;
this.userId = userId;
}

public User call() throws DaoException {
User user = userDao.getUserById(userId);
return user;
}
}

3，用之前的GetFromDB类构造一个FutureTask类
Java代码
FutureTask<User> dbtask = new FutureTask<User>(GetFromDB);

4，提交并执行
Java代码
threadpool.submit(dbtask);

5，得到返回值
Java代码
try {
User user = dbtask.get();
} catch (Exception e) {
if (e instanceof ExecutionException
&& ((ExecutionException) e).getCause() instanceof DaoException) {
throw (DaoException) ((ExecutionException) e).getCause();
} else {
其他处理方式
}
}

注：一旦调用了get()方法，如果线程还未产生返回值，则将阻塞get()方法，直到得到返回值。基于此，如果你想确保线程执行完后才执行下一步操作，即使你不想得到返回值也可以调用一下此方法。当然这与多线程的初衷不符。