java Thread与Runable

Love The Way You Lie 2023-10-17 16:46 20阅读 0赞

### 1.线程的定义 ###

线程是一个程序的多个执行路径，执行调度的单元，依托于进程的存在。线不仅可以共享进程的内在，而且还拥有一个属于自己的内存空间，这段内存空间就是线程栈，是在建立线程时系统分配的，主要用来保存线内部所使用的数据，如线程执行函数中所定义的变量，线程的状态等信息。

Java中的多线程是一个抢占机制，抢占机制指的是多个线程处于可运行状态，但只是允许一个线程运行，他们通过竞争方式抢占CPU。

### 2.实现线程的两种方式 ###

定义一个线程（Defining a Thread）有两种方法：

\[1\] 继承java.lang.Thread类，重写run()方法

\[java\] [view plain][] [copy][view plain]

1.  /\*\*
2.   \* 使用继承java.lang.Thread类的方式创建一个线程
3.   \*
4.   \* 
5.   \*/
6.  **public****class** ThreadTest **extends** Thread \{ 
7.  
8.  /\*\*
9.   \* 重写（Override）run()方法 JVM会自动调用该方法
10.  \*/
11. **public****void** run() \{ 
12.  System.out.println("Thread running!"); 
13.  \} 
14. \}

重写(override)run()方法在该线程的start()方法被调用后，JVM会自动调用run方法来执行任务。

\[2\] 实现java.lang.Runnable接口，并将其传入到Thread类对象中

\[java\] [view plain][] [copy][view plain]

1.  /\*\*
2.   \* 通过实现Runnable接口创建一个线程
3.   \* @author DreamSea
4.   \*/
5.  **public****class** ThreadTest **implements** Runnable \{ 
6.  **public****void** run() \{ 
7.   System.out.println("Runable running!"); 
8.   \} 
9.  \}

### 3.线程启动 ###

任何一个线程的执行的前提都是必须有Thread class的实例存在，并且通过调用run()方法启动线程。

\[1\] 如果线程是继承Thread类，则创建方式如下：

\[java\] [view plain][] [copy][view plain]

1.  ThreadTest1 tt = **new** ThreadTest1(); 
2.  tt.start();

\[2\] 如果是实现Runnable接口，则创建方式如下：

\[java\] [view plain][] [copy][view plain]

1.  ThreadTest2 tt = **new** ThreadTest2(); 
2.  Thread t = **new** Thread(tt); 
3.  t.start();

### 4.线程的状态 ###

\[1\] 新生状态（New）：当一个线程的实例被创建即使用new关键字和Thread类或其子类创建一个线程对象后，此时该线程处于新生(new)状态，处于新生状态的线程有自己的内存空间，但该线程并没有运行，此时线程还不是活着的（not alive）。  
  
\[2\] 就绪状态（Runnable）：通过调用线程实例的start()方法来启动线程使线程进入就绪状态(runnable)；处于就绪状态的线程已经具备了运行条件，但还没有被分配到CPU即不一定会被立即执行，此时处于线程就绪队列，等待系统为其分配CPCU，等待状态并不是执行状态； 此时线程是活着的（alive）。  
  
\[3\] 运行状态（Running）：一旦获取CPU(被JVM选中)，线程就进入运行(running)状态，线程的run()方法才开始被执行；在运行状态的线程执行自己的run()方法中的操作，直到调用其他的方法而终止、或者等待某种资源而阻塞、或者完成任务而死亡；如果在给定的时间片内没有执行结束，就会被系统给换下来回到线程的等待状态；此时线程是活着的（alive）。  
  
\[4\] 阻塞状态（Blocked）：通过调用join()、sleep()、wait()或者资源被暂用使线程处于阻塞(blocked)状态；处于Blocking状态的线程仍然是活着的（alive）。  
  
\[5\] 死亡状态（Dead）：当一个线程的run()方法运行完毕或被中断或被异常退出，该线程到达死亡(dead)状态。此时可能仍然存在一个该Thread的实例对象，当该Thread已经不可能在被作为一个可被独立执行的线程对待了，线程的独立的call stack已经被dissolved。一旦某一线程进入Dead状态，他就再也不能进入一个独立线程的生命周期了。对于一个处于Dead状态的线程调用start()方法，会出现一个运行期(runtime exception)的异常；处于Dead状态的线程不是活着的（not alive）。

线程的状态转换图如下所示：

![1362050775_2404.jpg][]

### 5.线程的方法、属性 ###

**\[1\] 优先级（priority）**

每个类都有自己的优先级，一般property用1-10的整数表示，默认优先级是5，优先级最高是10；优先级高的线程并不一定比优先级低的线程执行的机会高，只是执行的机率高；默认一个线程的优先级和创建他的线程优先级相同。  
  
\[2\] Thread.sleep()/sleep(long millis)  
当前线程睡眠/millis的时间（millis指定睡眠时间是其最小的不执行时间，因为sleep(millis)休眠到达后，无法保证会被JVM立即调度）；sleep()是一个静态方法(static method) ，所以他不会停止其他的线程也处于休眠状态；线程sleep()时不会失去拥有的对象锁。 作用：保持对象锁，让出CPU，调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留一定的时间给其他线程执行的机会。  
  
\[3\] Thread.yield()  
让出CPU的使用权，给其他线程执行机会、让同等优先权的线程运行（但并不保证当前线程会被JVM再次调度、使该线程重新进入Running状态），如果没有同等优先权的线程，那么yield()方法将不会起作用。  
  
\[4\] Thread.join()  
使用该方法的线程会在此之间执行完毕后再往下继续执行。  
  
\[5\] object.wait()  
当一个线程执行到wait()方法时，他就进入到一个和该对象相关的等待池(Waiting Pool)中，同时失去了对象的机锁---暂时的，wait后还要返还对象锁。当前线程必须拥有当前对象的锁，如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常,所以wait()必须在synchronized block中调用。  
  
\[6\] Object.notify()/notifyAll()  
唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁，否则也会抛出IllegalMonitorStateException异常。  
  
\[7\] Synchronizing Block  
Synchronized Block/方法控制对类成员变量的访问；Java中的每一个对象都有唯一的一个内置的锁，每个Synchronized Block/方法只有持有调用该方法被锁定对象的锁才可以访问，否则所属线程阻塞；机锁具有独占性、一旦被一个Thread持有，其他的Thread就不能再拥有（不能访问其他同步方法），方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

### 6.Object.wait()和Thread.sleep(long)的区别 ###

\[1\] sleep()方法  
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。  
sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。  
在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。  
  
\[2\] wait()方法  
wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁），其他线程可以访问。  
wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。  
wiat()必须放在synchronized block中，否则会在program runtime时扔出"java.lang.IllegalMonitorStateException"异常。

**总结一下：**

sleep()睡眠时，保持对象锁，仍然占有该锁。

wait()睡眠时，释放对象锁。

[view plain]: http://blog.csdn.net/leehong2005/article/details/8623374#
[1362050775_2404.jpg]: https://img-my.csdn.net/uploads/201302/28/1362050775_2404.jpg