java多线程编程技术详解和实例代码
java多线程编程技术详解和实例代码
1. Java和他的API都可以使用并发。
可以指定程序包含不同的执行线程，每个线程都具有自己的方法调用堆栈和程序计数器，使得线程在与其他线程并发地执行能够共享程序范围内的资源，比如共享内存，这种能力被称为多线程编程（multithreading）,在核心的C和C++语言中并不具备这种能力，尽管他们影响了JAVA的设计。
2. 线程的生命周期
新线程的生命周期从“新生”状态开始。程序启动线程前，线程一直是“新生”状态；程序启动线程后，线程进入“可运行”状态。“可运行”状态的线程，被认为是正在执行他的任务。
在程序启动线程之前，线程一直处于“等待”状态，只有当另一个线程通知正在等待的线程继续执行时，这个线程才会从“等待”状态恢复到“可运行”状态。
“可运行”状态的线程可以进入“定时等待”状态，等待一个指定的时间段。当时间到达或线程正在等待的某个事件发生时，该线程就会返回“可运行”状态。即使处理器可以使用，处于“定时等待”状态和“等待”状态的线程也不能用它。当处于“可运行”状态的线程正在等待另一个线程执行任务时，如果它提供了可选的等待时间段，则这个线程会进入“定时等待”状态。当另一个线程通知了这个线程，或者当定时的时间段到达时（以先满足的为准），这个线程就会返回到“可运行”状态.。使线程进入“定时等待”状态的另一方法是是处于“可运行”状态的线程睡眠。睡眠线程会在“定时等待”状态维持一个指定的时间段（称为睡眠时间段），过了这段时间，它会返回到“可运行”状态。当线程没有工作要执行时，它会立即睡眠。；例
当线程试图执行某个任务，而任务又不能立即完成，线程就从“可运行”状态转到“阻塞”状态。；例。即使有处理器可供使用，“阻塞”状态的线程也不能使用它。
线程成功完成任务，或者（由于出错）终止了时，“可运行”线程就会进入“终止”状态（有时称“停滞”状态）。
在操作系统级别，JAVA的“可运行”状态通常包含两个独立的状态。当线程首先从“新生”状态转到“可运行”状态，线程处于“就绪”状态。当操作系统将线程给处理器时，线程就从“就绪”状态进入“运行”状态（即开始执行），这也被称为“调度线程”。大多数操作系统中，每个线程被赋予一小段处理器时间（时间片）来执行任务。当时间片到达时，线程就会返回到“就绪”状态，而操作系统将另一个线程给予处理器。
3. 线程优先级与线程调度
JAVA的线程优先级范围为MIN_PRIORITY(常量1)到MAX_PRIORITY(常量10)，默认是NORM_PRIORITY(常量5)
4. 创建并执行线程
创建线程推介实现Runnable接口
（1）Runnable与Thread类
//Fig.4.1:PrintTask.java
//PrintTaskclasssleepsforarandomtimefrom0to5seconds
importjava.util.Random;
publicclassPrintTaskimplementsRunnable
{
privatefinalintsleepTime;//randomsleeptimeforthread
privatefinalStringtaskName;//nameoftask
privatefinalstaticRandomgenerator=newRandom();
publicPrintTask(Stringname)
{
taskName=name;//settaskname
//pickrandomsleeptimebetween0and5seconds
sleepTime=generator.nextInt(5000);//milliseconds
}//endPrintTaskconstructor
//methodruncontainsthecodethatathreadwillexecute
publicvoidrun()
{
try//putthreadtosleepforsleepTimeamountoftime
{
System.out.printf("%sgoingtosleepfor%dmilliseconds.\n",
taskName,sleepTime);
Thread.sleep(sleepTime);//putthreadtosleep
}//endtry
catch(InterruptedExceptionexception)
{
System.out.printf("%s%s\n",taskName,
"terminatedprematurelyduetointerruption");
}//endcatch
//printtaskname
System.out.printf("%sdonesleeping\n",taskName);
}//endmethodrun
}//endclassPrintTask
//Fig.4.2ThreadCreator.java
//CreatingandstartingthreethreadstoexecuteRunnables.
importjava.lang.Thread;
publicclassThreadCreator
{
publicstaticvoidmain(String[]args)
{
System.out.println("Creatingthreads");
//createeachthreadwithanewtargetedrunnable
Threadthread1=newThread(newPrintTask("task1"));
Threadthread2=newThread(newPrintTask("task2"));
Threadthread3=newThread(newPrintTask("task3"));
System.out.println("Threadscreated,startingtasks.");
//startthreadsandplaceinrunnablestate
thread1.start();//invokestask1抯runmethod
thread2.start();//invokestask2抯runmethod
thread3.start();//invokestask3抯runmethod
System.out.println("Tasksstarted,mainends.\n");
}//endmain
}//endclassRunnableTester
（2）线程管理与Executor框架
5为显示的创建线程，但推介使用Executor接口，用来管理Runnable对象的执行。Executor对象创建并管理一组Runnable对象的线程，这组线程就做线程池（threadpool）.优点是Executor对象能复用了已经有的线程，减少为每个任务创建新线程的开销，提高性能。
Executor接口只声明了一个名称为execute的方法，接收一个Runnable实参。Executor会将传递给他的execute方法的每个Runnable对象赋予线程池中可以用的线程。如果没有可以用的线程，则Executor会创建一个新线程，或等待某个线程会成为可用的，并会将这个线程赋予传递给execute方法的Runnable对象。
ExecutorService接口扩展了Executor接口。
//Fig.4.3:TaskExecutor.java
//UsinganExecutorServicetoexecuteRunnables.
importjava.util.concurrent.Executors;
importjava.util.concurrent.ExecutorService;
publicclassTaskExecutor
{
publicstaticvoidmain(String[]args)
{
//createandnameeachrunnable
PrintTasktask1=newPrintTask("task1");
PrintTasktask2=newPrintTask("task2");
PrintTasktask3=newPrintTask("task3");
System.out.println("StartingExecutor");
//createExecutorServicetomanagethreads
ExecutorServicethreadExecutor=Executors.newCachedThreadPool();
//startthreadsandplaceinrunnablestate
threadExecutor.execute(task1);//starttask1
threadExecutor.execute(task2);//starttask2
threadExecutor.execute(task3);//starttask3
//shutdownworkerthreadswhentheirtaskscomplete
threadExecutor.shutdown();
System.out.println("Tasksstarted,mainends.\n");
}//endmain
}//endclassTaskExecutor
5. 线程同步
（1）线程同步（threadsynchronization），协调多个并发线程对共享数据的访问。这种方式同步多个线程，就可以保证访问共享对象的每个线程都能同步地将其他所有线程排除在外，这被称为“互斥”。
另一个方法，使用JAVA内置的监控器（monitor）。每个对象都有一个监控器和监控锁（或内置锁）。监控器保证任何时候监控锁由具有最大可能的唯一一个线程持有。
（2）同步的数据共享：执行原子操作。
//AddsintegerstoanarraysharedwithotherRunnables
importjava.lang.Runnable;
publicclassArrayWriterimplementsRunnable
{
privatefinalSimpleArraysharedSimpleArray;
privatefinalintstartValue;
publicArrayWriter(intvalue,SimpleArrayarray)
{
startValue=value;
sharedSimpleArray=array;
}//endconstructor
publicvoidrun()
{
for(inti=startValue;i
//Fig5.2:SharedArrayTest.java
//ExecutestwoRunnablestoaddelementstoasharedSimpleArray.
importjava.util.concurrent.Executors;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.TimeUnit;
publicclassSharedArrayTest
{
publicstaticvoidmain(String[]arg)
{
//constructthesharedobject
SimpleArraysharedSimpleArray=newSimpleArray(6);
//createtwotaskstowritetothesharedSimpleArray
ArrayWriterwriter1=newArrayWriter(1,sharedSimpleArray);
ArrayWriterwriter2=newArrayWriter(11,sharedSimpleArray);
//executethetaskswithanExecutorService
ExecutorServiceexecutor=Executors.newCachedThreadPool();
executor.execute(writer1);
executor.execute(writer2);
executor.shutdown();
try
{
//wait1minuteforbothwriterstofinishexecuting
booleantasksEnded=executor.awaitTermination(
1,TimeUnit.MINUTES);
if(tasksEnded)
System.out.println(sharedSimpleArray);//printcontents
else
System.out.println(
"Timedoutwhilewaitingfortaskstofinish.");
}//endtry
catch(InterruptedExceptionex)
{
System.out.println(
"Interruptedwhilewaitfortaskstofinish.");
}//endcatch
}//endmain
}//endclassSharedArrayTest
//Fig.5.3:SimpleArray.java
//Classthatmanagesanintegerarraytobesharedbymultiple
//threadswithsynchronization.
importjava.util.Random;
publicclassSimpleArray
{
privatefinalintarray[];//thesharedintegerarray
privateintwriteIndex=0;//indexofnextelementtobewritten
privatefinalstaticRandomgenerator=newRandom();
//constructaSimpleArrayofagivensize
publicSimpleArray(intsize)
{
array=newint[size];
}//endconstructor
//addavaluetothesharedarray
publicsynchronizedvoidadd(intvalue)
{
intposition=writeIndex;//storethewriteindex
try
{
//putthreadtosleepfor0-499milliseconds
Thread.sleep(generator.nextInt(500));
}//endtry
catch(InterruptedExceptionex)
{
ex.printStackTrace();
}//endcatch
//putvalueintheappropriateelement
array[position]=value;
System.out.printf("%swrote%2dtoelement%d.\n",
Thread.currentThread().getName(),value,position);
++writeIndex;//incrementindexofelementtobewrittennext
System.out.printf("Nextwriteindex:%d\n",writeIndex);
}//endmethodadd
//usedforoutputtingthecontentsofthesharedintegerarray
publicStringtoString()
{
StringarrayString="\nContentsofSimpleArray:\n";
for(inti=0;i
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！