关于线程Word下载.docx
《关于线程Word下载.docx》由会员分享，可在线阅读，更多相关《关于线程Word下载.docx（20页珍藏版）》请在冰豆网上搜索。
如果一个任务无法做下去了，比如工作人员等待另一部门的信息，则工作人员将这个工作放在一边，转入另一个工作。
一般来说，老板希望工作人员手头的各个任务每一天都有一些进展。
这样就引入了多线程的概念。
多线程编程环境与这个典型的办公室非常相似，同时给CPU分配了几个任务或线程。
和办公室人员一样，计算机CPU实际上不可能同一时间做几件事，而是把时间分配到不同的线程，使每个线程都有点进展。
如果一个线程无法进行，比如线程要求的键盘输入尚未取得，则转入另一线程的工作。
通常，CPU在线程间的切换非常迅速，使人们感觉到好象所有线程是同时进行的。
任何处理环境，无论是单线程还是多线程，都有三个关键方面。
第一个是CPU，它实际上进行计算机活动；
第二个是执行的程序的代码；
第三个是程序操作的数据。
在多线程编程中，每个线程都用编码提供线程的行为，用数据供给编码操作。
多个线程可以同时处理同一编码和数据，不同的线程也可能各有不同的编码和数据。
事实上编码和数据部分是相当独立的，需要时即可向线程提供。
因此经常是几个线程使用同一编码和不同的数据。
这个思想也可以用办公室工作人员来比喻。
会计可能要做一个部门的帐或几个或几个部门的帐。
任何情况的做帐的任务是相同的程序代码，但每个部门的数据是不同的。
会计可能要做整个公司的帐，这时有几个任务，但有些数据是共享的，因为公司帐需要来自各个部门的数据。
多线程编程环境用方便的模型隐藏CPU在任务切换间的事实。
模型允许假装成有多个可用的CPU。
为了建立另一个任务，编程人员要求另一个虚拟CPU，指示它开始用某个数据组执行某个程序段。
下面我们来建立线程。
建立线程
在JAVA中建立线程并不困难，所需要的三件事：
执行的代码、代码所操作的数据和执行代码的虚拟CPU。
虚拟CPU包装在Thread类的实例中。
建立Thread对象时，必须提供执行的代码和代码所处理的数据。
JAVA的面向对象模型要求程序代码只能写成类的成员方法。
数据只能作为方法中的自动（或本地）变量或类的成员存在。
这些规则要求为线程提供的代码和数据应以类的实例的形式出现。
PublicclassSimpleRunnableimplemantsRunable{
PrivateStringmessage;
Publicstaticvoidmain（Stringargs[]）{
SimpleRunnabler1=newSimpleRunnable（“Hello”）;
Threadt1=newThread（r1）;
t1.start（）;
}
publicSimpleRunnable（Stringmessage）{
this.message=message;
publicvoidrun（）{
for（;
;
）{
System.out.println（message）;
线程开始执行时，它在publicvoidrun（）方法中执行。
这种方法是定义的线程执行的起点，就象应用程序从main（）开始、小程序从init（）开始一样。
线程操作的本地数据是传入线程的对象的成员。
首先，main（）方法构造SimpleRunnable类的实例。
注意，实例有自己的数据，这里是一个String,初始化为”Hello”.由于实例r1传入Thread类构造器，这是线程运行时处理的数据。
执行的代码是实例方法run（）。
2.2线程的管理
单线程的程序都有一个main执行体，它运行一些代码，当程序结束执行后，它正好退出，程序同时结束运行。
在JAVA中我们要得到相同的应答，必须稍微进行改动。
只有当所有的线程退出后，程序才能结束。
只要有一个线程一直在运行，程序就无法退出。
线程包括四个状态：
new（开始）,running（运行）,wait（等候）和done（结束）。
第一次创建线程时，都位于new状态，在这个状态下，不能运行线程，只能等待。
然后，线程或者由方法start开始或者送往done状态，位于done中的线程已经结束执行，这是线程的最后一个状态。
一旦线程位于这个状态，就不能再次出现，而且当JAVA虚拟机中的所有线程都位于done状态时，程序就强行中止。
当前正在执行的所有线程都位于running状态，在程序之间用某种方法把处理器的执行时间分成时间片，位于running状态的每个线程都是能运行的，但在一个给定的时间内，每个系统处理器只能运行一个线程。
与位于running状态的线程不同，由于某种原因，可以把已经位于waiting状态的线程从一组可执行线程中删除。
如果线程的执行被中断，就回到waiting状态。
用多种方法能中断一个线程。
线程能被挂起，在系统资源上等候，或者被告知进入休眠状态。
该状态的线程可以返回到running状态，也能由方法stop送入done状态，
方法
描述
有效状态
目的状态
Start（）
开始执行一个线程
New
Running
Stop（）
结束执行一个线程
New或running
Done
Sleep（long）
暂停一段时间，这个时间为给定的毫秒
Wait
Sleep（long,int）
暂停片刻，可以精确到纳秒
Suspend（）
挂起执行
Resume（）
恢复执行
Yield（）
明确放弃执行
2.3线程的调度
线程运行的顺序以及从处理器中获得的时间数量主要取决于开发者，处理器给每个线程分配一个时间片，而且线程的运行不能影响整个系统。
处理器线程的系统或者是抢占式的，或者是非抢占式的。
抢占式系统在任何给定的时间内将运行最高优先级的线程，系统中的所有线程都有自己的优先级。
Thread.NORM_PRIORITY是线程的缺省值，Thread类提供了setPriority和getPriority方法来设置和读取优先权，使用setPriority方法能改变Java虚拟机中的线程的重要性，它调用一个整数，类变量Thread.MIN_PRIORITY和Thread.MAX_PRIORITY决定这个整数的有效范围。
Java虚拟机是抢占式的，它能保证运行优先级最高的线程。
在JAVA虚拟机中我们把一个线程的优先级改为最高，那么他将取代当前正在运行的线程，除非这个线程结束运行或者被一条休眠命令放入waiting状态，否者将一直占用所有的处理器的时间。
如果遇到两个优先级相同的线程，操作系统可能影响线程的执行顺序。
而且这个区别取决于时间片（timeslicing）的概念。
管理几个线程并不是真正的难题，对于上百个线程它是怎样管理的呢？
当然可以通过循环，来执行每一个线程，但是这显然是冗长、乏味。
JAVA创建了线程组。
线程组是线程的一个谱系组，每个组包含的线程数不受限制，能对每个线程命名并能在整个线程组中执行（Suspend）和停止（Stop）这样的操作。
2.4信号标志：
保护其它共享资源
这种类型的保护被称为互斥锁。
某个时间只能有一个线程读取或修改这个数据值。
在对文件尤其是信息数据库进行处理时，读取的数据总是多于写数据，根据这个情况，可以简化程序。
下面举一例，假设有一个雇员信息的数据库，其中包括雇员的地址和电话号码等信息，有时要进行修改，但要更多的还是读数据，因此要尽可能防止数据被破坏或任意删改。
我们引入前面互斥锁的概念，允许一个读取锁（redlock）和写入锁（writelock）,可根据需要确定有权读取数据的人员。
一、认识多任务、多进程、单线程、多线程
要认识多线程就要从操作系统的原理说起。
以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。
比如你在copy东西的时候不能rename文件名。
为了提高系统的利用效率，采用批处理来批量执行任务。
现在的操作系统都是多任务操作系统，每个运行的任务就是操作系统所做的一件事情，比如你在听歌的同时还在用MSN和好友聊天。
听歌和聊天就是两个任务，这个两个任务是“同时”进行的。
一个任务一般对应一个进程，也可能包含好几个进程。
比如运行的MSN就对应一个MSN的进程，如果你用的是windows系统，你就可以在任务管理器中看到操作系统正在运行的进程信息。
一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有些会启动多个进程。
启动进程的时候，操作系统会为进程分配资源，其中最主要的资源是内存空间，因为程序是在内存中运行的。
在进程中，有些程序流程块是可以乱序执行的，并且这个代码块可以同时被多次执行。
实际上，这样的代码块就是线程体。
线程是进程中乱序执行的代码流程。
当多个线程同时运行的时候，这样的执行模式成为并发执行。
多线程的目的是为了最大限度的利用CPU资源。
Java编写程序都运行在在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。
每用java命令启动一个java应用程序，就会启动一个JVM进程。
在同一个JVM进程中，有且只有一个进程，就是它自己。
在这个JVM环境中，所有程序代码的运行都是以线程来运行。
一般常见的Java应用程序都是单线程的。
比如，用java命令运行一个最简单的HelloWorld的Java应用程序时，就启动了一个JVM进程，JVM找到程序程序的入口点main（），然后运行main（）方法，这样就产生了一个线程，这个线程称之为主线程。
当main方法结束后，主线程运行完成。
JVM进程也随即退出。
对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。
因此，线程间的通信很容易，速度也很快。
不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。
实际上，操作的系统的多进程实现了多任务并发执行，程序的多线程实现了进程的并发执行。
多任务、多进程、多线程的前提都是要求操作系统提供多任务、多进程、多线程的支持。
在Java程序中，JVM负责线程的调度。
线程调度是值按照特定的机制为多个线程分配CPU的使用权。
调度的模式有两种：
分时调度和抢占式调度。
分时调度是所有线程轮流获得CPU使用权，并平均分配每个线程占用CPU的时间；
抢占式调度是根据线程的优先级别来获取CPU的使用权。
JVM的线程调度模式采用了抢占式模式。
所谓的“并发执行”、“同时”其实都不是真正意义上的“同时”。
众所周知，CPU都有个时钟频率，表示每秒中能执行cpu指令的次数。
在每个时钟周期内，CPU实际上只能去执行一条（也有可能多条）指令。
操作系统将进程线程进行管理，轮流（没有固定的顺序）分配每个进程很短的一段是时间（不一定是均分），然后在每个线程内部，程序代码自己处理该进程内部线程的时间分配，多个线程之间相互的切换去执行，这个切换时间也是非常短的。
因此多任务、多进程、多线程都是操作系统给人的一种宏观感受，从微观角度看，程序的运行是异步执行的。
用一句话做总结：
虽然操作系统是多线程的，但CPU每一时刻只能做一件事，和人的大脑是一样的，呵呵。
二、Java与多线程
Java语言的多线程需要操作系统的支持。
Java虚拟机允许应用程序并发地运行多个执行线程。
Java语言提供了多线程编程的扩展点，并给出了功能强大的线程控制API。
在Java中，多线程的实现有两种方式：
扩展java.lang.Thread类
实现java.lang.Runnable接口
每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。
每个线程都可以或不可以标记为一个守护程序。
当某个线程中运行的代码创建一个新Thread对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。
当Java虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的main方法）。
Java虚拟机会继续执行线程，直到下列任一情况出现时为止：
调用了Runtime类的exit方法，并且安全管理器允许退出操作发生。
非守护线程的所有线程都已停止运行，无论是通过从对run方法的调用中返回，还是通过抛出一个传播到run方法之外的异常。
三、扩展java.lang.Thread类
/**
*FileName:
TestMitiThread.java
*Createdby:
IntelliJIDEA.
*Copyright:
Copyright（c）2003-2006
*Company:
Lavasoft（[url]
*Author:
leizhimin
*Modifier:
*DateTime:
2007-5-1710:
03:
12
*Readme:
通过扩展Thread类实现多线程
*/
publicclassTestMitiThread{
publicstaticvoidmain（String[]rags）{
System.out.println（Thread.currentThread（）.getName（）+"
线程运行开始!
"
）;
newMitiSay（"
A"
）.start（）;
B"
线程运行结束!
}
}
classMitiSayextendsThread{
publicMitiSay（StringthreadName）{
super（threadName）;
publicvoidrun（）{
System.out.println（getName（）+"
for（inti=0;
i<
10;
i++）{
System.out.println（i+"
"
+getName（））;
try{
sleep（（int）Math.random（）*10）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
运行结果：
main线程运行开始!
main线程运行结束!
A线程运行开始!
0A
1A
B线程运行开始!
2A
0B
3A
4A
1B
5A
6A
7A
8A
9A
A线程运行结束!
2B
3B
4B
5B
6B
7B
8B
9B
B线程运行结束!
说明：
程序启动运行main时候，java虚拟机启动一个进程，主线程main在main（）调用时候被创建。
随着调用MitiSay的两个对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。
在一个方法中调用Thread.currentThread（）.getName（）方法，可以获取当前线程的名字。
在mian方法中调用该方法，获取的是主线程的名字。
注意：
start（）方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
从程序运行的结果可以发现，多线程程序是乱序执行。
因此，只有乱序执行的代码才有必要设计为多线程。
Thread.sleep（）方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。
四、实现java.lang.Runnable接口
*通过实现Runnable接口实现多线程
publicclassTestMitiThread1implementsRunnable{
publicstaticvoidmain（String[]args）{
TestMitiThread1test=newTestMitiThread1（）;
Threadthread1=newThread（test）;
Threadthread2=newThread（test）;
thread1.start（）;
thread2.start（）;
+Thread.currentThread（）.getName（））;
Thread.sleep（（int）Math.random（）*10）;
Thread-0线程运行开始!
0Thread-0
Thread-1线程运行开始!
0Thread-1
1Thread-1
1Thread-0
2Thread-0
2Thread-1
3Thread-0
3Thread-1
4Thread-0
4Thread-1
5Thread-0
6Thread-0
5Thread-1
7Thread-0
8Thread-0
6Thread-1
9Thread-0
7Thread-1
Thread-0线程运行结束!
8Thread-1
9Thread-1
Thread-1线程运行结束!
TestMitiThread1类通过实现Runnable接口，使得该类有了多线程类的特征。
run（）方法是多线程程序的一个约定。
所有的多线程代码都在run方法里面。
Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread（Runnabletarget）构造出对象，然后调用Thread对象的start（）方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start（）方法来运行的。
因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
五、读解Thread类API
staticintMAX_PRIORITY
线程可以具有的最高优先级。
staticintMIN_PRIORITY
线程可以具有的最低优先级。
staticintNORM_PRIORITY
分配给线程的默认优先级。
构造方法摘要
Thread（Runnabletarget）
分配新的Thread对象。
Thread（Stringname）
方法摘要
staticThreadcurrentThread（）
返
升级会员 