6．1 线程简介

　　随着计算机的飞速发展，个人计算机上的操作系统也纷纷采用多任务和分时设计，将早期只有大型计算机才具有的系统特性带到了个人计算机系统中。一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程概念中，每一个进程的内部数据和状态都是完全独立的。Java程序通过流控制来执行程序流，程序中单个顺序的流控制称为线程，多线程则指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。

　　线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weight process）。一个进程中可以包含多个线程。

　　一个线程是一个程序内部的顺序控制流。
　　1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。
　　2. 线程：轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（pc），线程切换的开销小。
　　3. 多进程：在操作系统中，能同时运行多个任务程序。
　　4. 多线程：在同一应用程序中，有多个顺序流同时执行。

　　6．1．1 线程的概念模型

　　java内在支持多线程，它的所有类都是在多线程下定义的，java利用多线程使整个系统成为异步系统。java中的线程由三部分组成，如图6.1所示。

　　1. 虚拟的cpu，封装在java.lang.thread类中。
　　2. cpu所执行的代码，传递给thread类。
　　3. cpu所处理的数据，传递给thread类。

　　图6.1线程

　　6. 1. 2 线程体(1)


　　java的线程是通过java.lang.thread类来实现的。当我们生成一个thread类的对象之后,一个新的线程就产生了。

　　此线程实例表示java解释器中的真正的线程，通过它可以启动线程、终止线程、线程挂起等，每个线程都是通过类thread在java的软件包java.lang中定义，它的构造方法为：

　　　public thread （threadgroup group，runnable target，string name）；

　　其中，group 指明该线程所属的线程组；target实际执行线程体的目标对象，它必须实现接口runnable； name为线程名。java中的每个线程都有自己的名称，java提供了不同thread类构造器，允许给线程指定名称。如果name为null时，则java自动提供唯一的名称。
　　当上述构造方法的某个参数为null时，我们可得到下面的几个构造方法：

　　public thread （）；
　　public thread （runnable target）；
　　public thread （runnable target，string name）；
　　public thread （string name）；
　　public thread （threadgroup group，runnable target）；
　　public thread （threadgroup group，string name）；

　　一个类声明实现runnable接口就可以充当线程体，在接口runnable中只定义了一个方法 run（）：
　　　　　　　public void run（）；

　　任何实现接口runnable的对象都可以作为一个线程的目标对象，类thread本身也实现了接口runnable，因此我们可以通过两种方法实现线程体。

　　（一）定义一个线程类，它继承线程类thread并重写其中的方法 run（），这时在初始化这个类的实例时，目标target可为null，表示由这个实例对来执行线程体。由于java只支持单重继承，用这种方法定义的类不能再继承其它父类。

　　（二）提供一个实现接口runnable的类作为一个线程的目标对象，在初始化一个thread类或者thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体 run（）。这时，实现接口runnable的类仍然可以继承其它父类。

　　每个线程都是通过某个特定thread对象的方法run( )来完成其操作的，方法run( )称为线程体。图6.2表示了java线程的不同状态以及状态之间转换所调用的方法。

　　图6.2 线程的状态
　　　　
　　 1. 创建状态(new thread)
　　执行下列语句时，线程就处于创建状态：
　　thread mythread = new mythreadclass( );
　　当一个线程处于创建状态时，它仅仅是一个空的线程对象，系统不为它分配资源。

　　2. 可运行状态( runnable )
　　thread mythread = new mythreadclass( );
　　mythread.start( );
　　当一个线程处于可运行状态时，系统为这个线程分配了它需的系统资源，安排其运行并调用线程运行方法，这样就使得该线程处于可运行( runnable )状态。需要注意的是这一状态并不是运行中状态（running )，因为线程也许实际上并未真正运行。由于很多计算机都是单处理器的，所以要在同一时刻运行所有的处于可运行状态的线程是不可能的，java的运行系统必须实现调度来保证这些线程共享处理器。
　　
　　3. 不可运行状态（not runnable）
　　进入不可运行状态的原因有如下几条：
　　1) 调用了sleep（）方法;
　　2) 调用了suspend（）方法;
　　3) 为等候一个条件变量，线程调用wait（）方法;
　　4) 输入输出流中发生线程阻塞;
　　不可运行状态也称为阻塞状态（blocked）。因为某种原因（输入/输出、等待消息或其它阻塞情况），系统不能执行线程的状态。这时即使处理器空闲，也不能执行该线程。

　　4. 死亡状态（dead）
　　线程的终止一般可通过两种方法实现：自然撤消（线程执行完）或是被停止（调用stop()方法）。目前不推荐通过调用stop()来终止线程的执行，而是让线程执行完。

　　

　　6. 1. 2 线程体(2)


　　◇线程体的构造

　　任何实现接口runnable的对象都可以作为一个线程的目标对象，上面已讲过构造线程体有两种方法，下面通过实例来说明如何构造线程体的。

　　例6．1 通过继承类thread构造线程体
　　class simplethread extends thread {
　　public simplethread(string str) {
　　　super(str); //调用其父类的构造方法
　　}
　　public void run() { //重写run方法
　　　for (int i = 0; i < 10; i++) {
　　　　system.out.println(i + " " + getname());
　　　　　　　　　　　　　//打印次数和线程的名字
　　　　try {
　　　　　　sleep((int)(math.random() * 1000));
　　　　　　　　　　　　　//线程睡眠，把控制权交出去
　　　　} catch (interruptedexception e) {}
　　}

　　　　　system.out.println("done! " + getname());
　　　　　　　　　　　　　//线程执行结束
　　　　}
　　}
　　public class twothreadstest {
　　　public static void main (string args[]) {
　　　　new simplethread("first").start();
　　　　　　　　　　　　　//第一个线程的名字为first
　　　　new simplethread("second").start();
　　　　　　　　　　　　　//第二个线程的名字为second
　　}
　　}

　　　运行结果:
　　　　0 first
　　　　0 second
　　　　1 second
　　　　1 first
　　　　2 first
　　　　2 second
　　　　3 second
　　　　3 first
　　　　4 first
　　　　4 second
　　　　5 first
　　　　5 second
　　　　6 second
　　　　6 first
　　　　7 first
　　　　7 second
　　　　8 second
　　　　9 second
　　　　8 first
　　　　done! second
　　　　9 first
　　　　done! first

　　仔细分析一下运行结果，会发现两个线程是交错运行的，感觉就象是两个线程在同时运行。但是实际上一台计算机通常就只有一个cpu，在某个时刻只能是只有一个线程在运行，而java语言在设计时就充分考虑到线程的并发调度执行。对于程序员来说，在编程时要注意给每个线程执行的时间和机会，主要是通过让线程睡眠的办法（调用sleep()方法）来让当前线程暂停执行，然后由其它线程来争夺执行的机会。如果上面的程序中没有用到sleep()方法，则就是第一个线程先执行完毕，然后第二个线程再执行完毕。所以用活sleep()方法是学习线程的一个关键。


　　例6．2 通过接口构造线程体
　　　public class clock extends java.applet.applet implements runnable {//实现接口
　　　　　　thread clockthread;
　　　　　　public void start() {
　　　　　　　　　//该方法是applet的方法，不是线程的方法
　　　　　　if (clockthread == null) {
　　　　　　　　　clockthread = new thread(this, "clock");
　　　　　　　　　/*线程体是clock对象本身，线程名字为"clock"*/
　　　　　　　　　clockthread.start(); //启动线程
　　　　　　　　　}
　　　　　　}

　　　　　　public void run() { //run()方法中是线程执行的内容
　　　　　　　　　while (clockthread != null) {
　　　　　　　　　repaint(); //刷新显示画面
　　　　　　　　　try {
　　　　　　　　　　　clockthread.sleep(1000);
　　　　　　　　　　　//睡眠1秒，即每隔1秒执行一次
　　　　　　　　　　} catch (interruptedexception e){}
　　　　　　　　　}
　　　　　　}

　　　　　　public void paint(graphics g) {
　　　　　　　　　　date now = new date(); //获得当前的时间对象
　　　　　　　　　　g.drawstring(now.gethours() + ":" + now.getminutes()+ ":" +now.getseconds(), 5, 10);//显示当前时间
　　　　　　}

　　　　　　public void stop() {
　　　　　　　　//该方法是applet的方法，不是线程的方法
　　　　　　　　　　clockthread.stop();
　　　　　　　　　　clockthread = null;
　　　　　　}
　　　}

　　上面这个例子是通过每隔1秒种就执行线程的刷新画面功能，显示当前的时间；看起来的效果就是一个时钟，每隔1秒就变化一次。由于采用的是实现接口runnable的方式，所以该类clock还继承了applet, clock就可以applet的方式运行。

　　构造线程体的两种方法的比较：

　　1. 使用runnable接口
　　　1) 可以将cpu，代码和数据分开，形成清晰的模型;
　　　2) 还可以从其他类继承;
　　　3) 保持程序风格的一致性。

　　2. 直接继承thread类
　　　1) 不能再从其他类继承;
　　　2) 编写简单，可以直接操纵线程，无需使用thread.currentthread()。

　　6．1．3 线程的调度


　　java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪些线程来执行。

　　线程调度器按线程的优先级高低选择高优先级线程（进入运行中状态）执行，同时线程调度是抢先式调度，即如果在当前线程执行过程中，一个更高优先级的线程进入可运行状态，则这个线程立即被调度执行。

　　抢先式调度又分为：时间片方式和独占方式。在时间片方式下，当前活动线程执行完当前时间片后，如果有其他处于就绪状态的相同优先级的线程，系统会将执行权交给其他就绪态的同优先级线程；当前活动线程转入等待执行队列，等待下一个时间片的调度。

　　在独占方式下，当前活动线程一旦获得执行权，将一直执行下去，直到执行完毕或由于某种原因主动放弃cpu，或者是有一高优先级的线程处于就绪状态。

　　下面几种情况下，当前线程会放弃cpu:

　　1. 线程调用了yield() 或sleep() 方法主动放弃；

　　2. 由于当前线程进行i/o 访问，外存读写，等待用户输入等操作，导致线程阻塞；或者是为等候一个条件变量，以及线程调用wait（）方法；

　　3. 抢先式系统下，由高优先级的线程参与调度；时间片方式下，当前时间片用完，由同优先级的线程参与调度。

　　线程的优先级

　　线程的优先级用数字来表示，范围从1到10，即thread.min_priority到thread.max_priority。一个线程的缺省优先级是5，即thread.norm_priority。下述方法可以对优先级进行操作：

　　int getpriority(); //得到线程的优先级
　　void setpriority(int newpriority);
　　//当线程被创建后，可通过此方法改变线程的优先级

　　例6．3中生成三个不同线程，其中一个线程在最低优先级下运行，而另两个线程在最高优先级下运行。

　　例6．3
　　class threadtest{
　　　　public static void main( string args [] ) {
　　　　　　thread t1 = new mythread("t1");
　　　　　　t1.setpriority( thread.min_priority ); //设置优先级为最小
　　　　　　t1.start( );
　　　　　　thread t2 = new mythread("t2");
　　　　　　t2.setpriority( thread.max_priority ); //设置优先级为最大
　　　　　　t2.start( );
　　　　　　thread t3 = new mythread("t3");
　　　　　　t3.setpriority( thread.max_priority ); //设置优先级为最大
　　　　　　t3.start( );
　　　　}
　　　　　　　　}

　　　class mythread extends thread {
　　　　　string message;
　　　　　mythread ( string message ) {
　　　　　　　　this.message = message;
　　　　　}
　　　　　public void run() {
　　　　　　　for ( int i=0; i<3; i++ )
　　　　　　　　system.out.println( message+" "+getpriority() );
　　　　　　　　　　　　　　　　　　　　　　　　　//获得线程的优先级
　　　　　}
　　　　　　　　}

　　运行结果：
　　　　　　　t2 10
　　　　　　　t2 10
　　　　　　　t2 10
　　　　　　　t3 10
　　　　　　　t3 10
　　　　　　　t3 10
　　　　　　　t1 1
　　　　　　　t1 1
　　　　　　　t1 1

　　注意：并不是在所有系统中运行java程序时都采用时间片策略调度线程，所以一个线程在空闲时应该主动放弃cpu，以使其他同优先级和低优先级的线程得到执行。

　　6．1．4基本的线程控制

　　1．终止线程

　　线程终止后，其生命周期结束了，即进入死亡态，终止后的线程不能再被调度执行，以下几种情况，线程进入终止状态：
　　1) 线程执行完其run()方法后，会自然终止。
　　2) 通过调用线程的实例方法stop()来终止线程。

　　2． 测试线程状态

　　可以通过thread 中的isalive() 方法来获取线程是否处于活动状态；线程由start() 方法启动后，直到其被终止之间的任何时刻，都处于'alive'状态。

　　3． 线程的暂停和恢复

　　有几种方法可以暂停一个线程的执行，在适当的时候再恢复其执行。
　　1) sleep() 方法
　　当前线程睡眠（停止执行）若干毫秒，线程由运行中状态进入不可运行状态，停止执行时间到后线程进入可运行状态。

　　2) suspend()和resume()方法
　　线程的暂停和恢复，通过调用线程的suspend()方法使线程暂时由可运行态切换到不可运行态，若此线程想再回到可运行态，必须由其他线程调用resume()方法来实现。
　　注：从jdk1.2开始就不再使用suspend()和resume()。

　　3) join()
　　当前线程等待调用该方法的线程结束后, 再恢复执行.
　　timerthread tt=new timerthread(100);
　　tt.start();
　　…
　　public void timeout(){
　　tt.join();// 当前线程等待线程tt 执行完后再继续往下执行
　　… }

　　

　　6．2多线程的互斥与同步

　　临界资源问题

　　前面所提到的线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。例6．4说明了此问题。

　　例6．4
　　class stack{
　　　int idx=0; //堆栈指针的初始值为0
　　　char[ ] data = new char[6]; //堆栈有6个字符的空间

　　　public void push(char c){ //压栈操作
　　　　data[idx] = c; //数据入栈
　　　　idx + +; //指针向上移动一位
　　　}

　　　　　public char pop(){ //出栈操作
　　　　　　　idx - -; //指针向下移动一位
　　　　　　　return data[idx]; //数据出栈
　　　　　}
　　　}


　　两个线程a和b在同时使用stack的同一个实例对象，a正在往堆栈里push一个数据，b则要从堆栈中pop一个数据。如果由于线程a和b在对stack对象的操作上的不完整性，会导致操作的失败，具体过程如下所示：

　　1) 操作之前
　　　　　data = | p | q | | | | | idx=2


　　2) a执行push中的第一个语句，将r推入堆栈；
　　　　　data = | p | q | r | | | | idx=2

　　3) a还未执行idx++语句，a的执行被b中断，b执行pop方法，返回q：
　　　　　data = | p | q | r | | | | idx=1

　　4〕a继续执行push的第二个语句：
　　　　　data = | p | q | r | | , | | idx=2
　　
　　最后的结果相当于r没有入栈。产生这种问题的原因在于对共享数据访问的操作的不完整性。

　　6．2．1 互斥锁

　　为解决操作的不完整性问题，在java 语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问。

　　　　public void push(char c){
　　　　synchronized(this){ //this表示stack的当前对象
　　　　　　　data[idx]=c;
　　　　　　　idx++;
　　　　}
　　　　}
　　　　public char pop(){
　　　　　　　synchronized(this){ //this表示stack的当前对象
　　　　　　　idx--;
　　　　　　　return data[idx];
　　　　　　　}
　　　　}



　　synchronized 除了象上面讲的放在对象前面限制一段代码的执行外，还可以放在方法声明中，表示整个方法为同步方法。
　　public synchronized void push(char c){
　　…
　　　　}

　　如果synchronized用在类声明中，则表明该类中的所有方法都是synchronized的。

　　

　　6．2．2多线程的同步

　　 本节将讨论如何控制互相交互的线程之间的运行进度,即多线程之间的同步问题,下面我们将通过多线程同步的模型: 生产者-消费者问题来说明怎样实现多线程的同步。

　　我们把系统中使用某类资源的线程称为消费者，产生或释放同类资源的线程称为生产者。
　　在下面的java的应用程序中，生产者线程向文件中写数据，消费者从文件中读数据，这样，在这个程序中同时运行的两个线程共享同一个文件资源。通过这个例子我们来了解怎样使它们同步。


　　例6．5
　　　class syncstack{ //同步堆栈类
　　　private int index = 0; //堆栈指针初始值为0
　　　private char []buffer = new char[6]; //堆栈有6个字符的空间

　　　public synchronized void push(char c){ //加上互斥锁
　　　　　while(index = = buffer.length){ //堆栈已满，不能压栈
　　　　　try{
　　　　　　　　this.wait(); //等待，直到有数据出栈
　　　　　　　}catch(interruptedexception e){}
　　　　　　　}

　　　this.notify(); //通知其它线程把数据出栈
　　　buffer[index] = c; //数据入栈
　　　index++; //指针向上移动
　　　}

　　　public synchronized char pop(){ //加上互斥锁
　　　　　　　while(index ==0){ //堆栈无数据，不能出栈
　　　　　　　　try{
　　　　　　　　　　　this.wait(); //等待其它线程把数据入栈
　　　　　　　　}catch(interruptedexception e){}
　　　　　　　　　　}

　　　　　　　this.notify(); //通知其它线程入栈
　　　　　　　index- -; //指针向下移动
　　　　　　　return buffer[index]; //数据出栈
　　　　}
　　　　　　　}

　　　　class producer implements runnable{ //生产者类
　　　　　　　syncstack thestack;
　　　　　　　　//生产者类生成的字母都保存到同步堆栈中

　　　　　　　public producer(syncstack s){
　　　　　　　　　　thestack = s;
　　　　　　　}

　　　　　　　public void run(){
　　　　　　　　　　char c;
　　　　　　　　　　for(int i=0; i<20; i++){
　　　　　　　　　　　　c =(char)(math.random()*26+'a');
　　　　　　　　　　　　　　　　　　　　　　　　　　//随机产生20个字符
　　　　　　　　　　　　thestack.push(c); //把字符入栈
　　　　　　　　　　　　system.out.println("produced: "+c); //打印字符
　　　　　　　　　　　　try{
　　　　　　　　　　　　thread.sleep((int)(math.random()*1000));
　　　　　　　　　　　　　　　　　　　　　/*每产生一个字符线程就睡眠*/
　　　　　　　　　　　　}catch(interruptedexception e){}
　　　　　　　　　　}
　　　　　　　}
　　　　　}

　　　　　class consumer implements runnable{ //消费者类
　　　　　　　　　syncstack thestack;
　　　　　　　　　　　　　　　　　　//消费者类获得的字符都来自同步堆栈

　　　　　　　　　public consumer(syncstack s){
　　　　　　　　　　　　　thestack = s;
　　　　　　　　　}

　　　　　　　　　public void run(){
　　　　　　　　　　　　　char c;
　　　　　　　　　　　　　for(int i=0;i<20;i++){
　　　　　　　　　　　　　　　c = thestack.pop(); //从堆栈中读取字符
　　　　　　　　　　　　　system.out.println("consumed: "+c);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//打印字符
　　　　　　　　　　　　　try{
　　　　　　　　　　　　　thread.sleep((int)(math.random()*1000));
　　　　　　　　　　　　　　　　　　　　/*每读取一个字符线程就睡眠*/
　　　　　　　　　　　　　}catch(interruptedexception e){}
　　　　　　　　　}
　　　　　　　}
　　　　　}

　　　　　public class synctest{
　　　　　　　public static void main(string args[]){
　　　　　　　　　syncstack stack = new syncstack();
　　　//下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
　　　　　　　　　runnable source=new producer(stack);
　　　　　　　　　runnable sink = new consumer(stack);
　　　　　　　　　thread t1 = new thread(source); //线程实例化
　　　　　　　　　thread t2 = new thread(sink); //线程实例化
　　　　　　　　　t1.start(); //线程启动
　　　　　　　　　t2.start(); //线程启动
　　　　　　　}
　　　　　}

　　类producer是生产者模型，其中的 run()方法中定义了生产者线程所做的操作，循环调用push()方法,将生产的20个字母送入堆栈中，每次执行完push操作后，调用sleep()方法睡眠一段随机时间，以给其他线程执行的机会。类consumer是消费者模型，循环调用pop()方法,从堆栈中取出一个数据，一共取20次，每次执行完pop操作后，调用sleep()方法睡眠一段随机时间，以给其他线程执行的机会。

　　程序执行结果
　　　　　　　　produced:v
　　　　　　　　consumed:v
　　　　　　　　produced:e
　　　　　　　　consumed:e
　　　　　　　　produced:p
　　　　　　　　produced:l
　　　　　　　　...
　　　　　　　　consumed:l
　　　　　　　　consumed:p

　　在上述的例子中，通过运用wait()和notify()方法来实现线程的同步，在同步中还会用到notifyall()方法，一般来说，每个共享对象的互斥锁存在两个队列，一个是锁等待队列，另一个是锁申请队列，锁申请队列中的第一个线程可以对该共享对象进行操作，而锁等待队列中的线程在某些情况下将移入到锁申请队列。下面比较一下wait()、notify()和notifyall()方法：

　　(1) wait,nofity,notifyall必须在已经持有锁的情况下执行,所以它们只能出现在synchronized作用的范围内，也就是出现在用　　 　　　　synchronized修饰的方法或类中。

　　(2) wait的作用:释放已持有的锁,进入等待队列.
　　
　　(3) notify的作用:唤醒wait队列中的第一个线程并把它移入锁申请队列.

　　(4) notifyall的作用:唤醒wait队列中的所有的线程并把它们移入锁申请队列.

　　注意：
　　1） suspend()和resume()
　　　　在jdk1.2中不再使用suspend()和resume(),其相应功能由wait()和notify()来实现。

　　2) stop()
　　　 在jdk1.2中不再使用stop(),而是通过标志位来使程序正常执行完毕。例6.6就是一个典型的例子。

　　例6．6
　　　public class xyz implements runnable {
　　　　　　private boolean timetoquit=false; //标志位初始值为假
　　　　　　public void run() {
　　　　　　　　　while(!timetoquit) {//只要标志位为假，线程继续运行
　　　　　　　　　　　　　…
　　　　　　　　　}
　　　　　　}

　　　public void stoprunning() {
　　　　　　　　　timetoquit=true;} //标志位设为真，表示程序正常结束
　　　　　　}
　　　public class controlthread {
　　　　　　private runnable r=new xyz();
　　　　　　private thread t=new thread(r);
　　　　　　public void startthread() {
　　　　　　　　　t.start();
　　　　　　}
　　　　　　public void stopthread() {
　　　　　　　　　r.stoprunning(); }
　　　　　　　　　　　　　　　//通过调用stoprunning方法来终止线程运行
　　　　　　}
$3Z@x,32I/D;kylTY [ 本 资 料 来 源 于 贵 州 学 习 网 网络编程Java教程 http://Www.gzU521.com ] $3Z@x,32I/D;kylTY