线程的基本概念
线程的概念：线程就是应用程序中的一个可执行线索，多线程就是同一个应用程序中有多个可执行线索，它们可以并发执行。
线程开始执行时，它在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。
