线程的基本概念

线程的概念：线程就是应用程序中的一个可执行线索，多线程就是同一个应用程序中有多个可执行线索，它们可以并发执行。

线程开始执行时，它在public void run()方法中执行。

该方法是定义的线程执行起点，像应用程序从main()开始

一样。

首先main()方法构造SimpleRunnable类的实例。实例

有自己的一个String数据,初始化为"Hello"。由实例传入

Thread类构造器，这是线程运行时处理的数据。

执行的代码是实例方法run()。

一个建立线程的例子

public class SimpleRunnable implements Runable{

private String message;

public static void main(String args[]){

SimpleRunnable r1=new SimpleRunnable("Hello");

Thread t1=new Thread(r1);

t1.start();

}

public SimpleRunnable(String message){

this.message = message;

}

public void run(){

for(;;){

System.out.println(message);

}

}

创建Thread类的子类

用这种方法生成新线程，可以按以下步骤进行：

生成Thread类的子类。

class MyThread extends Thread

1.在子类中重写run()方法。

public void run()

2.生成子类的对象，并且调用start()方法启动新线程。

MyThread thread = new MyThread();

thread.start();

3. start()方法将调用run()方法执行线程。

实现Thread子类方法的多线程示例

class FirstThread extends Thread {

public void run() {

try{

System.out.println("First thread starts running.");

for(int i=0; i<6; i++) {

System.out.println("First " + i);

sleep(1000);

}

System.out.println("First thread finishes running.");

} catch (InterruptedException e) {}

}

}

实现Thread子类方法的多线程示例

class SecondThread extends Thread {

public void run() {

try{

System.out.println("\tSecond thread starts running.");

for(int i=0; i<6; i++) {

System.out.println("\tSecond " + i);

sleep(1000);

}

System.out.println("\tSecond thread finishes running");

}catch (InterruptedException e) {}

}

}

实现Thread子类方法的多线程示例

public class ThreadTest1 {

public ThreadTest1() {

FirstThread first = new FirstThread();

SecondThread second = new SecondThread();

first.start();

second.start();

}

public static void main(String[] args) {

new ThreadTest1();

}

}

结果为：

First thread starts running.

First 0

Second thread starts running.

Second 0

First 1

Second 1

First 2

Second 2

First 3

Second 3

First 4

Second 4

First 5

Second 5

First thread finishes running.

Second thread finished.

run方法是运行线程的主体,启动线程时,由java直接调用 public void run()

停止线程,由小应用程序的stop调用线程的stop thread.stop()

sleep方法的作用,暂停线程的执行,让其它线程得到机会,sleep要丢出异常,必须捕获。

Try{sleep(100)}catch(InterruptedException e){}

实现Runnable接口

Runnable是java.lang包中的一个接口。

定义了创建和执行线程的功能。

定义了run()方法，完成具体任务的地方。

实现Runnable接口的主要步骤：

1.定义一个类实现Runnable接口，

class FirstThread implements Runnable

并且在该类中实现run()方法。

public void run()

生成这个类的对象。

FirstThread first = new FirstThread();

2.用Thread(Runnable target)构造函数生成Thread对象，然后调用start()方法启动线程。

Thread thread1 = new Thread(first);

thread1.start();

实现Runnable接口多线程示例

class FirstThread implements Runnable {

public void run() {

try {

System.out.println("First thread starts running.");

for(int i=0; i<6; i++) {

System.out.println("First " + i);

Thread.sleep(1000);

}

System.out.println("First thread finishes running.");

} catch (InterruptedException e) {}

}

}

class SecondThread implements Runnable {

public void run() {

try {

System.out.println("\tSecond thread starts running.");

for(int i=0; i<6; i++) {

System.out.println("\tSecond " + i);

Thread.sleep(1000);

}

System.out.println("\tSecond thread finished.");

}catch(InterruptedException e) {}

}

}

public class RunTest {

public RunTest() {

FirstThread first = new FirstThread();

SecondThread second = new SecondThread();

Thread thread1 = new Thread(first);

Thread thread2 = new Thread(second);

thread1.start();

thread2.start();

}

public static void main(String[] args) {

new RunTest();

}

}

结果为：

First thread starts running.

First 0

Second thread starts running.

Second 0

First 1

Second 1

First 2

Second 2

First 3

Second 3

First 4

Second 4

First 5

Second 5

First thread finishes running.

Second thread finished.

1．线程的状态

具有四种状态：

新生态：已分配内在，未高度

可执行态：start( )

阻塞态

停止态：stop( )

1，新建：

当一个Thread类或其子类的对象被创建后，进入这个状态。

这时，线程对象已被分配内存空间，其私有数据已被初始化，但该线程还未被调度，可用start()方法调度，或用stop()方法中止。

新生线程一旦被调度，就将切换到可执行状态。

2．可运行：

处于可执行环境中，随时可以被调度而执行。它可细分为两个子状态：

运行状态，已获得CPU，正在执行；

就绪状态，只等待处理器资源。

这两个子状态的过渡由执行调度器来控制。

3．阻塞：

由某种原因引起线程暂停执行的状态。

4．死亡：

线程执行完毕或另一线程调用stop()方法使其停止时，进入这种停止状态。

它表示线程已退出可运行状态，并且不再进入可运行状态。

线程优先级

Java把优先级划分为10级，用1至10的整数表示，数值越大，优先级越高。

在Thread类中定义了三个优先级常量：MIN_PRIORITY, MAX_PRIORITY和NORM_PRIORITY，其值分别为1, 10, 5。

在为线程分配优先级时，其值应该在1至10之间，否则将出错。

如果应用程序没有为线程分配优先级，则Java系统为其赋值为NORM_PRIORITY。

线程调度原则

调度就是分配CPU资源，确定线程的执行顺序。

Java采用抢占式调度方式，即高优先级线程具有剥夺低优先级线程执行的权力。

如果一个低优先线程正在执行，这时出现一个高优先级线程，那么低优先级线程就只能停止执行，放弃CPU，推回到等待队列中，等待下一轮执行，而让高优先级线程立即执行。

如果线程具有相同的优先级，则按"先来先服务"的原则调度。

Thread类定义了许多控制线程执行的方法。▼

程序中经常使用下面的方法，对线程进行控制：

start()：用于调用run()方法使线程开始执行。

stop()： 立即停止线程执行，其内部状态清零，放弃占用资源。

suspend()：暂停线程执行。线程的所有状态和资源保持不变，以后可以通过另一线程调用resume()方法来重新启动这个线程。

resume()：恢复暂停的线程，安排暂停线程执行。

sleep()： 调整Java执行时间，所需参数是指定线程的睡眠时间，以毫秒为单位。

join()：调用线程等待本线程执行结束。

yield()：暂停调度线程并将其放在等待队列末尾，等待下一轮执行，使同优先级的 其它线程有机会执行 。

isAlive()：判断线程目前是否正在执行状态中

线程处于“新建”状态时，线程调用方法返回false。

当一个线程调用start（）方法，并占有CUP资源后，该线程的run方法就开始运行，在线程的run方法结束之前，即没有进入死亡状态之前，线程调用isAlive()方法返回true。

当线程进入“死亡”状态后（实体内存被释放），线程仍可以调用方法isAlive（），这时返回的值是false。