线程基础

最新推荐文章于 2022-11-18 10:59:34 发布

iteye_3276

最新推荐文章于 2022-11-18 10:59:34 发布

阅读量72

点赞数

分类专栏： Java线程文章标签：多线程 thread Oracle Linux 虚拟机

本文链接：https://blog.csdn.net/iteye_3276/article/details/82033102

版权

Java线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

线程不是进程

作为有一定开发经验的程序员来说，在java中实现多线程是一件很容易的事情，你只需要将你的类继承Thread类或者实现Runnable接口就可以。其实线程完全可以理解为一个任务。可以同时运行多个任务的程序，就成为多线程程序。

然而线程并非进程。进程包括线程，每一个进程都拥有一套自己的变量，而线程间则共享这套变量。从而带来了很多风险，比如最典型的脏数据。这些以后会讨论。

线程状态

在java中，线程被定义成有6中状态：

NEW

至今尚未启动的线程处于这种状态。即刚刚new出来的Thread，但是还未调用start（）方法。

RUNNABLE

正在 Java 虚拟机中执行的线程处于这种状态。该状态是调用了start()方法后的状态，出于该状态的线程不一定是正在运行的，他有线程调度器来决定是否运行。

BLOCKED

受阻塞并等待某个监视器锁的线程处于这种状态。阻塞与等待不同，阻塞通常是得不到所需要的资源而被迫停下来等待。

WAITING

无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。

TIMED_WAITING

等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

TERMINATED

已退出的线程处于这种状态。有两种情况会让线程退出，其一是run方法中的任务执行完成，其二是线程执行时出现异常。

java的线程状态只有如上6中，他们以enum形式被定义在Thread.State中。这里要说一下等待状态，有很多方式能够让线程进入等待状态，比如调用join（）方法。

join()

对于这个方法，还是要特别的强调一下。在api中的解释如下：Blocks the current Thread (Thread.currentThread()) until the receiver finishes its execution and dies.翻译过来就是：阻塞当前线程，然后让接受者完成任务之后，当前线程才开始继续执行任务。

但是如果接受者在被调用了join方法后，有被调用了interrupt()方法，则会抛出 java.lang.InterruptedException异常。可以参考代码ThreadDemo01。

Java代码

<STRONG>package cn.edu.heut.zcl;
public class ThreadDemo01 {
public static void main(String[] args) {
TA ta = new TA();
ta.start();
try {
ta.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
int i = 0;
while ((i++) < 10) {
System.out.println("-------");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class TA extends Thread {
@Override
public void run() {
super.run();
int i = 0;
while ((i++) < 40) {
System.out.println("---->A");
if (i == 10) {
Thread.currentThread().interrupt();
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
</STRONG>

package cn.edu.heut.zcl;

 

public class ThreadDemo01 {

 

         public static void main(String[] args) {

                   TA ta = new TA();

                   ta.start();

                   try {

                            ta.join();

                   } catch (InterruptedException e) {

                            e.printStackTrace();

                   }

                   int i = 0;

                   while ((i++) < 10) {

                            System.out.println("-------");

                            try {

                                     Thread.sleep(100);

                            } catch (InterruptedException e) {

                                     e.printStackTrace();

                            }

                   }

         }

}

class TA extends Thread {

 

         @Override

         public void run() {

                   super.run();

                   int i = 0;

                   while ((i++) < 40) {

                            System.out.println("---->A");

                            if (i == 10) {

                                     Thread.currentThread().interrupt();

                            }


                            try {

                                     Thread.sleep(100);

                            } catch (InterruptedException e) {

                                     // TODO Auto-generated catch block

                                     e.printStackTrace();

                            }

                   }

         }

}

记住：join()方法是将当前线程阻塞

interrupt()与中断线程

开发时常常需要用到中断线程，在早期的java版本中，有stop()等方法用来控制线程生死，当时这些方法现在已经废弃，具体愿意以后会谈，同时亦可以参考sun的一片文章《Why Are Thread.stop, Thread.suspend, Thread.resume and Runtime.runFinalizersOnExit Deprecated?》网址如下：

http://download.oracle.com/javase/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html

当然，jdk还是为我们提供了强化终止线程的方法。然而，interrupt方法只是可以用来请求终止线程。当对一个线程调用interrupt方法之后，线程的中断状态将被置位。每一个线程都具有一个中断状态，他是一个boolean标志。在实现自己的线程时，应该实时检查该标志，以判断线程是否被中断。

可以通过Thread.currentThread()方法得到当前线程，然后通过is isInterrupted()方法，来查看中断状态。通常如下实现：

while (!Thread.currentThread().isInterrupted() && 。。。) {}

如果你已经运行了ThreadDemo01代码，那么你会发现，在TA类中如下代码处：

Java代码

if (i == 10) {
Thread.currentThread().interrupt();
}

if (i == 10) {

                                     Thread.currentThread().interrupt();

                            }

将会抛出异常java.lang.InterruptedException。这个是由于在TA线程中调用了interrupt方法后，中断状态已经置为，如果此时再调用sleep等阻塞方法后，该线程不会休眠，想法，他将抛出中断异常并且将中断状态清楚。所以如下代码是不会让线程TB停止。CopyOfThreadDemo02

Java代码

package cn.edu.heut.zcl;
public class CopyOfThreadDemo02 {
public static void main(String[] args) {
TB ta = new TB();
ta.start();
int i = 0;
while ((i++) < 10) {
System.out.println("-------");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class TB extends Thread {
@Override
public void run() {
super.run();
int i = 0;
while (!Thread.currentThread().isInterrupted() && (i++) < 40) {
System.out.println("---->A");
if(i == 4) Thread.currentThread().interrupt();//在sleep之前调用，将不能终止线程
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//if(i == 4) Thread.currentThread().interrupt();//在sleep之后调用，将能终止线程
}
}
}

package cn.edu.heut.zcl;

 

public class CopyOfThreadDemo02 {

 

         public static void main(String[] args) {

                   TB ta = new TB();

                   ta.start();

                   int i = 0;

                   while ((i++) < 10) {

                            System.out.println("-------");

                            try {

                                     Thread.sleep(100);

                            } catch (InterruptedException e) {

                                     e.printStackTrace();

                            }

                   }

         }

}

 

class TB extends Thread {

 

         @Override

         public void run() {

                   super.run();

                   int i = 0;

                   while (!Thread.currentThread().isInterrupted() && (i++) < 40) {

                            System.out.println("---->A");

                            if(i == 4) Thread.currentThread().interrupt();//在sleep之前调用，将不能终止线程

                            try {

                                     Thread.sleep(100);

                            } catch (InterruptedException e) {

                                     // TODO Auto-generated catch block

                                     e.printStackTrace();

                            }

                            //if(i == 4) Thread.currentThread().interrupt();//在sleep之后调用，将能终止线程

                   }

         }

}

你可以自己试一试，运行如上代码，不能中断TB线程。但是如果在sleep之后调用interrupt，则会中断线程。

interrupted()与isInterrupted()

这两个方法看上去很像，作用也相似可以通过下表来比较两种异同。

是否是static

返回值

不同

interrupted

是

当前的中断状态

调用后改变中断状态

isInterrupted

否

不改变

线程属性----线程优先级

谈优先级可能并不陌生，在java中，每一个线程都有一个优先级。默认情况下，一个线程的优先级直接继承自他的父类。sun将java的优先级分成10级，1表示最小优先级，10表示最高优先级。同时jdk中还定义了3个常量MIN_PRIORITY(1级)、MAX_PRIORITY(10级)、NORM_PRIORITY(5级)。