java多線程編程技術(shù)詳解和實例代碼
創(chuàng)新互聯(lián)服務(wù)項目包括武清網(wǎng)站建設(shè)、武清網(wǎng)站制作、武清網(wǎng)頁制作以及武清網(wǎng)絡(luò)營銷策劃等。多年來，我們專注于互聯(lián)網(wǎng)行業(yè)，利用自身積累的技術(shù)優(yōu)勢、行業(yè)經(jīng)驗、深度合作伙伴關(guān)系等，向廣大中小型企業(yè)、政府機構(gòu)等提供互聯(lián)網(wǎng)行業(yè)的解決方案，武清網(wǎng)站推廣取得了明顯的社會效益與經(jīng)濟效益。目前，我們服務(wù)的客戶以成都為中心已經(jīng)輻射到武清省份的部分城市，未來相信會繼續(xù)擴大服務(wù)區(qū)域并繼續(xù)獲得客戶的支持與信任！
1. Java和他的API都可以使用并發(fā)。
可以指定程序包含不同的執(zhí)行線程，每個線程都具有自己的方法調(diào)用堆棧和程序計數(shù)器，使得線程在與其他線程并發(fā)地執(zhí)行能夠共享程序范圍內(nèi)的資源，比如共享內(nèi)存，這種能力被稱為多線程編程（multithreading）,在核心的C和C++語言中并不具備這種能力，盡管他們影響了JAVA的設(shè)計。
2. 線程的生命周期
新線程的生命周期從“新生”狀態(tài)開始。程序啟動線程前，線程一直是“新生”狀態(tài)；程序啟動線程后，線程進入“可運行”狀態(tài)?！翱蛇\行”狀態(tài)的線程，被認(rèn)為是正在執(zhí)行他的任務(wù)。
在程序啟動線程之前，線程一直處于“等待”狀態(tài)，只有當(dāng)另一個線程通知正在等待的線程繼續(xù)執(zhí)行時，這個線程才會從“等待”狀態(tài)恢復(fù)到“可運行”狀態(tài)。
“可運行”狀態(tài)的線程可以進入“定時等待”狀態(tài)，等待一個指定的時間段。當(dāng)時間到達或線程正在等待的某個事件發(fā)生時，該線程就會返回“可運行”狀態(tài)。即使處理器可以使用，處于“定時等待”狀態(tài)和“等待”狀態(tài)的線程也不能用它。當(dāng)處于“可運行”狀態(tài)的線程正在等待另一個線程執(zhí)行任務(wù)時，如果它提供了可選的等待時間段，則這個線程會進入“定時等待”狀態(tài)。當(dāng)另一個線程通知了這個線程，或者當(dāng)定時的時間段到達時（以先滿足的為準(zhǔn)），這個線程就會返回到“可運行”狀態(tài).。使線程進入“定時等待”狀態(tài)的另一方法是是處于“可運行”狀態(tài)的線程睡眠。睡眠線程會在“定時等待”狀態(tài)維持一個指定的時間段（稱為睡眠時間段），過了這段時間，它會返回到“可運行”狀態(tài)。當(dāng)線程沒有工作要執(zhí)行時，它會立即睡眠。；例
當(dāng)線程試圖執(zhí)行某個任務(wù)，而任務(wù)又不能立即完成，線程就從“可運行”狀態(tài)轉(zhuǎn)到“阻塞”狀態(tài)。；例。即使有處理器可供使用，“阻塞”狀態(tài)的線程也不能使用它。
線程成功完成任務(wù)，或者（由于出錯）終止了時，“可運行”線程就會進入“終止”狀態(tài)（有時稱“停滯”狀態(tài)）。
在操作系統(tǒng)級別，JAVA的“可運行”狀態(tài)通常包含兩個獨立的狀態(tài)。當(dāng)線程首先從“新生”狀態(tài)轉(zhuǎn)到“可運行”狀態(tài)，線程處于“就緒”狀態(tài)。當(dāng)操作系統(tǒng)將線程給處理器時，線程就從“就緒”狀態(tài)進入“運行”狀態(tài)（即開始執(zhí)行），這也被稱為“調(diào)度線程”。大多數(shù)操作系統(tǒng)中，每個線程被賦予一小段處理器時間（時間片）來執(zhí)行任務(wù)。當(dāng)時間片到達時，線程就會返回到“就緒”狀態(tài)，而操作系統(tǒng)將另一個線程給予處理器。
3. 線程優(yōu)先級與線程調(diào)度
JAVA的線程優(yōu)先級范圍為MIN_PRIORITY(常量1)到MAX_PRIORITY(常量10)，默認(rèn)是NORM_PRIORITY(常量5)
4. 創(chuàng)建并執(zhí)行線程
創(chuàng)建線程推介實現(xiàn)Runnable接口
（1）Runnable與Thread類
重慶分公司
重慶分公司
// Fig. 4.1: PrintTask.java
// PrintTask class sleeps for a random time from 0 to 5 seconds
import java.util.Random;
public class PrintTask implements Runnable
{
private final int sleepTime; // random sleep time for thread
private final String taskName; // name of task
private final static Random generator = new Random();
public PrintTask( String name )
{
taskName = name; // set task name
// pick random sleep time between 0 and 5 seconds
sleepTime = generator.nextInt( 5000 ); // milliseconds
} // end PrintTask constructor
// method run contains the code that a thread will execute
public void run()
{
try // put thread to sleep for sleepTime amount of time
{
System.out.printf( "%s going to sleep for %d milliseconds.\n",
taskName, sleepTime );
Thread.sleep( sleepTime ); // put thread to sleep
} // end try
catch ( InterruptedException exception )
{
System.out.printf( "%s %s\n", taskName,
"terminated prematurely due to interruption" );
} // end catch
// print task name
System.out.printf( "%s done sleeping\n", taskName );
} // end method run
} // end class PrintTask
// Fig. 4.2 ThreadCreator.java
// Creating and starting three threads to execute Runnables.
import java.lang.Thread;
public class ThreadCreator
{
public static void main( String[] args )
{
System.out.println( "Creating threads" );
// create each thread with a new targeted runnable
Thread thread1 = new Thread( new PrintTask( "task1" ) );
Thread thread2 = new Thread( new PrintTask( "task2" ) );
Thread thread3 = new Thread( new PrintTask( "task3" ) );
System.out.println( "Threads created, starting tasks." );
// start threads and place in runnable state
thread1.start(); // invokes task1抯 run method
thread2.start(); // invokes task2抯 run method
thread3.start(); // invokes task3抯 run method
System.out.println( "Tasks started, main ends.\n" );
} // end main
} // end class RunnableTester
（2）線程管理與Executor框架
5為顯示的創(chuàng)建線程，但推介使用Executor接口，用來管理Runnable對象的執(zhí)行。Executor對象創(chuàng)建并管理一組Runnable對象的線程，這組線程就做線程池（thread pool）.優(yōu)點是Executor對象能復(fù)用了已經(jīng)有的線程，減少為每個任務(wù)創(chuàng)建新線程的開銷，提高性能。
Executor接口只聲明了一個名稱為execute的方法，接收一個Runnable實參。Executor會將傳遞給他的execute方法的每個Runnable對象賦予線程池中可以用的線程。如果沒有可以用的線程，則Executor會創(chuàng)建一個新線程，或等待某個線程會成為可用的，并會將這個線程賦予傳遞給execute方法的Runnable對象。
ExecutorService接口擴展了Executor接口。
// Fig. 4.3: TaskExecutor.java
// Using an ExecutorService to execute Runnables.
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class TaskExecutor
{
public static void main( String[] args )
{
// create and name each runnable
PrintTask task1 = new PrintTask( "task1" );
PrintTask task2 = new PrintTask( "task2" );
PrintTask task3 = new PrintTask( "task3" );
System.out.println( "Starting Executor" );
// create ExecutorService to manage threads
ExecutorService threadExecutor = Executors.newCachedThreadPool();
// start threads and place in runnable state
threadExecutor.execute( task1 ); // start task1
threadExecutor.execute( task2 ); // start task2
threadExecutor.execute( task3 ); // start task3
// shut down worker threads when their tasks complete
threadExecutor.shutdown();
System.out.println( "Tasks started, main ends.\n" );
} // end main
} // end class TaskExecutor
5. 線程同步
（1）線程同步（thread synchronization），協(xié)調(diào)多個并發(fā)線程對共享數(shù)據(jù)的訪問。這種方式同步多個線程，就可以保證訪問共享對象的每個線程都能同步地將其他所有線程排除在外，這被稱為“互斥”。
另一個方法，使用JAVA內(nèi)置的監(jiān)控器（monitor）。每個對象都有一個監(jiān)控器和監(jiān)控鎖（或內(nèi)置鎖）。監(jiān)控器保證任何時候監(jiān)控鎖由具有最大可能的唯一一個線程持有。
（2）同步的數(shù)據(jù)共享：執(zhí)行原子操作。
// Adds integers to an array shared with other Runnables
import java.lang.Runnable;
public class ArrayWriter implements Runnable
{
private final SimpleArray sharedSimpleArray;
private final int startValue;
public ArrayWriter( int value, SimpleArray array )
{
startValue = value;
sharedSimpleArray= array;
} // end constructor
public void run()
{
for ( int i = startValue; i < startValue + 3; i++ )
{
sharedSimpleArray.add( i ); // add an element to the shared array
} // end for
} // end method run
} // end class ArrayWrite
// Fig 5.2: SharedArrayTest.java
// Executes two Runnables to add elements to a shared SimpleArray.
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
public class SharedArrayTest
{
public static void main( String[] arg )
{
// construct the shared object
SimpleArray sharedSimpleArray = new SimpleArray( 6 );
// create two tasks to write to the shared SimpleArray
ArrayWriter writer1 = new ArrayWriter( 1, sharedSimpleArray );
ArrayWriter writer2 = new ArrayWriter( 11, sharedSimpleArray );
// execute the tasks with an ExecutorService
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute( writer1 );
executor.execute( writer2 );
executor.shutdown();
try
{
// wait 1 minute for both writers to finish executing
boolean tasksEnded = executor.awaitTermination(
1, TimeUnit.MINUTES );
if ( tasksEnded )
System.out.println( sharedSimpleArray ); // print contents
else
System.out.println(
"Timed out while waiting for tasks to finish." );
} // end try
catch ( InterruptedException ex )
{
System.out.println(
"Interrupted while wait for tasks to finish." );
} // end catch
} // end main
} // end class SharedArrayTest
// Fig.5.3 : SimpleArray.java
// Class that manages an integer array to be shared by multiple
// threads with synchronization.
import java.util.Random;
public class SimpleArray
{
private final int array[]; // the shared integer array
private int writeIndex = 0; // index of next element to be written
private final static Random generator = new Random();
// construct a SimpleArray of a given size
public SimpleArray( int size )
{
array = new int[ size ];
} // end constructor
// add a value to the shared array
public synchronized void add( int value )
{
int position = writeIndex; // store the write index
try
{
// put thread to sleep for 0-499 milliseconds
Thread.sleep( generator.nextInt( 500 ) );
} // end try
catch ( InterruptedException ex )
{
ex.printStackTrace();
} // end catch
// put value in the appropriate element
array[ position ] = value;
System.out.printf( "%s wrote %2d to element %d.\n",
Thread.currentThread().getName(), value, position );
++writeIndex; // increment index of element to be written next
System.out.printf( "Next write index: %d\n", writeIndex );
} // end method add
// used for outputting the contents of the shared integer array
public String toString()
{
String arrayString = "\nContents of SimpleArray:\n";
for ( int i = 0; i < array.length; i++ )
arrayString += array[ i ] + " ";
return arrayString;
} // end method toString
} // end class SimpleArray
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
