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()方法，直到得到返回值。基於此，如果你想確保線程執行完後才執行下一步操作，即使你不想得到返回值也可以調用一下此方法。當然這與多線程的初衷不符。