thread

小鱼儿 2022-06-09 23:06 120阅读 0赞

1   Thread

1.1 introductions

## java.lang   类 Thread ##

java.lang.Object

java.lang.Thread

**所有已实现的接口：**

Runnable

public class Thread

extends Object

implements Runnable

*线程* 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 `Thread` 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 `main` 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：

1.调用了 `Runtime` 类的 `exit` 方法，并且安全管理器允许退出操作发生。

2.非守护线程的所有线程都已停止运行，无论是通过从对 run 方法的调用中返回，还是通过抛出一个传播到 `run` 方法之外的异常。

创建新执行线程有两种方法。一种方法是将类声明为 `Thread` 的子类。该子类应重写 `Thread` 类的 `run` 方法。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以写成：

class PrimeThreadextends Thread \{

longminPrime;

PrimeThread(long minPrime) \{

this.minPrime = minPrime;

public voidrun() \{

//compute primes larger than minPrime

. . .

然后，下列代码会创建并启动一个线程：

PrimeThreadp = new PrimeThread(143);

p.start();

创建线程的另一种方法是声明实现 `Runnable` 接口的类。该类然后实现 `run` 方法。然后可以分配该类的实例，在创建 `Thread` 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：

classPrimeRun implements Runnable \{

long minPrime;

PrimeRun(long minPrime) \{

this.minPrime = minPrime;

public void run() \{

// compute primes larger thanminPrime

. . .

然后，下列代码会创建并启动一个线程：

PrimeRunp = new PrimeRun(143);

new Thread(p).start();

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

**从以下版本开始：**JDK1.0

**另请参见：**Runnable, Runtime.exit(int), run(), stop()

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>static&nbsp;</code><a title="java.lang 中的类" rel="nofollow">Thread</a></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">currentThread</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回对当前正在执行的线程对象的引用。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;</code><a title="java.lang 中的类" rel="nofollow">String</a></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">getName</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回该线程的名称。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;int</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">getPriority</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回线程的优先级。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">run</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;如果该线程是使用独立的 <code>Runnable</code> 运行对象构造的，则调用该 <code>Runnable</code> 对象的 <code>run</code> 方法；否则，该方法不执行任何操作并返回。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>static&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">sleep</a></strong><code>(long&nbsp;millis)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">start</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;使该线程开始执行；Java 虚拟机调用该线程的 <code>run</code> 方法。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;</code><a title="java.lang 中的类" rel="nofollow">String</a></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">toString</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回该线程的字符串表示形式，包括线程名称、优先级和线程组。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>static&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">yield</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;暂停当前正在执行的线程对象，并执行其他线程。</p> </td> 
  </tr> 
  <tr> 
   <td style="background:white"> <p><code>void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">setDaemon</a></strong><code>(boolean&nbsp;on)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;将该线程标记为守护线程或用户线程。<strong></strong></p> </td> 
  </tr> 
 </tbody> 
</table>

1.2 example

1.2.1   customizedThread

**public  class** MyThread **extends** Thread\{

**public  void** run() \{

**for**(**int** i=0;i<100;i\++)\{

System.***out***.println(i);

1.2.2   test

**public  static void** main(String\[\]  args)\{

MyThread myThread1=**new** MyThread();

//启动线程

myThread1.setName("hah");

myThread1.start();

MyThread myThread2=**new** MyThread();

myThread2.setName("线程2");

myThread2.start();

//Thread的currentThread()方法可以得到当前线程的对象

Thread.*currentThread*().setName("Main");

**for**(**int** i=0;i<100;i\++)\{

System.***out***.println(Thread.*currentThread*().getName()+"---"\+i);

@Test

//如果在test里面测试，会受到test线程的影响，不能饱和执行线程。

**public  void** testMyThread()\{

MyThread myThread=**new** MyThread();

//启动线程

myThread.setName("线程1");

myThread.start();

MyThread myThread1=**new** MyThread();

myThread1.setName("线程2");

myThread1.start();

2   Runnable

2.1 introduction

## java.lang   接口 Runnable ##

**所有已知子接口：**

RunnableFuture<V>,RunnableScheduledFuture<V>

**所有已知实现类：**

AsyncBoxView.ChildState, FutureTask,  RenderableImageProducer, SwingWorker, Thread,  TimerTask

public interface Runnable

`Runnable` 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 `run` 的无参数方法。

设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，`Thread` 类实现了 `Runnable`。激活的意思是说某个线程已启动并且尚未停止。

此外，`Runnable` 为非 `Thread` 子类的类提供了一种激活方式。通过实例化某个 `Thread` 实例并将自身作为运行目标，就可以运行实现 `Runnable` 的类而无需创建 `Thread` 的子类。大多数情况下，如果只想重写 `run()` 方法，而不重写其他 `Thread` 方法，那么应使用 `Runnable` 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类。

**从以下版本开始：** JDK1.0

**另请参见：**  Thread, Callable

2.2 使用Runnable接口实现类的底层原理

(1).Thread类实现自Runnable接口，且包含属性Runnable target。

**Publicclass** Thread **implements**  Runnable \{

**private  int**            priority;

**private** Thread         threadQ;

**private  long**           eetop;

....

**private** Runnable target;

(2).Runnable接口只有一个抽象方法

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">run</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;使用实现接口 <code>Runnable</code> 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 <code>run</code> 方法。</p> </td> 
  </tr> 
 </tbody> 
</table>

(3).Thread类本身的run方法源码，也是执行了自身Runnable属性的run方法。而采用继承Thread类创建线程子类的方式，是重写了这个run方法。重点代码见标红。

**public  void** run() \{

**if** (target != **null**) \{

target.run();

(4).Thread的传Runnable实例的构造方法源码。利用多态的特征，将实现了Runnable接口的类赋值给Thread自身的Runnable属性，从而调用的run方法就是实现类的run方法。

**public**  Thread(Runnable target, String  name) \{

init(**null**, target, name, 0);

**private  void** init(ThreadGroup  g, Runnable target, String  name,

**long** stackSize) \{

init(g,  target, name,  stackSize, **null**);

**private  void** init(ThreadGroup  g, Runnable target, String  name,

**long** stackSize,AccessControlContext  acc) \{

**if** (name == **null**) \{

**throw  new**NullPointerException("name cannot be null");

**this**.name = name.toCharArray();

Thread parent = *currentThread*();

SecurityManager security = System.*getSecurityManager*();

**if** (g == **null**) \{

**if** (security != **null**) \{

g =  security.getThreadGroup();

**if** (g == **null**) \{

g =  parent.getThreadGroup();

g.checkAccess();

**if** (security != **null**) \{

**if** (*isCCLOverridden*(getClass()))\{

security.checkPermission(***SUBCLASS\_IMPLEMENTATION\_PERMISSION***);

g.addUnstarted();

**this**.group = g;

**this**.daemon = parent.isDaemon();

**this**.priority = parent.getPriority();

**if** (security == **null** || *isCCLOverridden*(parent.getClass()))

**this**.contextClassLoader = parent.getContextClassLoader();

**else**

**this**.contextClassLoader = parent.contextClassLoader;

**this**.inheritedAccessControlContext =

acc != **null** ? acc :AccessController.*getContext*();

**this**.target = target;

setPriority(priority);

**if** (parent.inheritableThreadLocals != **null**)

**this**.inheritableThreadLocals =

ThreadLocal.*createInheritedMap*(parent.inheritableThreadLocals);

**this**.stackSize = stackSize;

tid = *nextThreadID*();

2.3 example

2.3.1   Runnable实现类

**public  class** MyRunnable **implements** Runnable\{

**public  void** run() \{

**for**(**int** i=0;i<100;i\++)\{

System.***out***.println(Thread.*currentThread*().getName()+"---"\+i);

2.3.2   test

**public  static void** main(String\[\]  args)\{

//创建任务对象

MyRunnable myrun=**new** MyRunnable();

//通过Thread类的构造方法分配新的Thread对象

Thread  t1=**new**  Thread(myrun,"run1");

Thread  t2=**new**  Thread(myrun,"run2");

Thread  t3=**new**  Thread(myrun,"run3");

t1.start();

t2.start();

t3.start();

3   Thread类的启动原理

run：用来封装线程任务的，无法启动线程

start：先启动线程，再调用run方法。

Threadl类的start方法源码，主要是调用了start0方法。而start0方法是native修饰的，也就是调用了一个非java代码的接口。由于启动线程涉及到jvm，所以这里的启动过程可能有c或者其他语言来实现的。重点代码标红。与这个问题相关的知识是，jvm是用c和汇编等语言开发的。在底层的要看start0方法所关联的c代码等了。

**public  synchronized void** start() \{

**if** (threadStatus != 0)

**throw  new**IllegalThreadStateException();

group.add(**this**);

**boolean** started = **false**;

**try** \{

start0();

started = **true**;

\} **finally** \{

**try** \{

**if** (!started) \{

group.threadStartFailed(**this**);

\} **catch** (Throwable ignore) \{

**private native  void** start0();

4   Thread常用的方法

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">setPriority</a></strong><code>(int&nbsp;newPriority)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;更改线程的优先级。</p> </td> 
  </tr> 
 </tbody> 
</table>

同样的，在底层源码中，setPriority方法中调用了native的setPriority0的方法。

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>static&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">sleep</a></strong><code>(long&nbsp;millis)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。</p> </td> 
  </tr> 
 </tbody> 
</table>

Sleep属于静态方法，需要用类调用。

**public  void** run() \{

**for**(**int** i=0;i<100;i\++)\{

**try** \{

Thread.*sleep*(100);

System.***out***.println(Thread.*currentThread*().getName()+"--"\+i);

\} **catch** (InterruptedException e) \{

e.printStackTrace();

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">join</a></strong><code>(long&nbsp;millis)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待该线程终止的时间最长为 <code>millis</code> 毫秒。</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>static&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">yield</a></strong><code>()</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;暂停当前正在执行的线程对象，并执行其他线程。</p> </td> 
  </tr> 
 </tbody> 
</table>

Yield属于静态方法，需要用类调用。

**public  void** run() \{

**for**(**int** i=0;i<100;i\++)\{

System.***out***.println(Thread.*currentThread*().getName()+"--"\+i);

Thread.*yield*();

<table> 
 <tbody> 
  <tr> 
   <td style="background:white"> <p><code>&nbsp;void</code></p> </td> 
   <td style="background:white"> <p><strong><a rel="nofollow">setDaemon</a></strong><code>(boolean&nbsp;on)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;将该线程标记为守护线程或用户线程。</p> </td> 
  </tr> 
 </tbody> 
</table>

setDaemon方法必须在启动线程前调用。

**public  static void** main(String\[\]  args)\{

//创建任务对象

MyRunnable myrun=**new** MyRunnable();

SleepTask st=**new** SleepTask();

YieldTask yt=**new** YieldTask();

//通过Thread类的构造方法分配新的Thread对象

Thread t1=**new** Thread(myrun,"run1");

Thread t2=**new** Thread(myrun,"run2");

Thread t3=**new** Thread(myrun,"run3");

Thread t4=**new** Thread(st,"runsleep");

Thread t5=**new** Thread(yt,"runyield");