java多线程基本方法（3）

JAVA 的多线程特性是它的一大优点。多线程是相对单线程而言的，单线程是指任何时候只能有一个程序在运行，其他程序必须等待。而有了多线程这个特性后，JAVA 可以支持多个程序并发执行。当你要写一个能同时执行多个功能的程序时，就需要用到JAVA 的多线程功能。JAVA 的多线程功能被封装在线程类中。

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口

1. 使用继承 Thread 类的方法实现多线程

package com.zsc.everyday;
//使用继承 Thread 类的方法实现多线程
public class FirstThread extends Thread {
	private int i  ;
	//重写 run 方法，run方法中的方法是现成的执行方法
	public void run(){
		for(;i<5;i++){
			// getName() 函数是获取线程名称
			System.out.println(getName()+"、"+i);
		}
	}
	public static void main(String[] args) {
		for(int i =0 ;i<5;i++){
			System.out.println(Thread.currentThread().getName()+"、"+i);
			if(i==2){
				//创建第一条线程，使用start()
				new FirstThread().start();
				new FirstThread().start();
			}
		}
	}
}

2. 通过实现Runnable接口：

package com.zsc.everyday;
//通过实现 Runnable 接口的方式实现多线程
public class SecondThread implements Runnable {
	private int i  ;
	//重写 run 方法，run方法中的方法是现成的执行方法
	public void run(){
		for(;i<5;i++){
			//获取线程名称 只能使用  Thread.currentThread().getName()
			System.out.println(Thread.currentThread().getName()+"、"+i);
		}
	}
	public static void main(String[] args) {
		for(int i =0 ;i<5;i++){
			System.out.println(Thread.currentThread().getName()+"、"+i);
			if(i==2){
				SecondThread st = new SecondThread();
				//通过 new Thread(target,name).start();  创建线程
				new Thread(st,"新线程1").start();
				new Thread(st,"新线程2").start();
			}
		}
	}
}

3. 两种实现多线程的区别：
在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程。
Thread Test = new Thread();
Test.start();

在使用Runnable的时候需要先new一个继承Runnable的实例，之后用子类Thread调用。
Test impelements Runnable
Test t = new Test();
Thread test = new Thread(t);

两种实现范式的区别：

Thread是用extends继承；
而Runnable是用implements继承，即实现抽象类；
如果你用extends继承了别的类，还想实现线程，那就用Runnable；
反之用Thread。

4. 控制线程

jion 线程：java让一个线程等另一个线程的方法：jion() 方法；

package com.zsc.everyday;
// join 方法 控制线程
public class JoinThread extends Thread{
	//提供一个有参数的构造器，用于设置该线程的名字
	public JoinThread(String name){
		super(name);
	}
	// 重写 run 方法，定义线程执行体
	public void run(){
		for(int i=0;i<5;i++){
			//获取线程名称 只能使用  Thread.currentThread().getName()
			System.out.println(Thread.currentThread().getName()+"、"+i);
		}
	}
	public static void main(String[] args) throws Exception {
		//启动子线程
		new JoinThread("新线程1").start();
		for(int i =0 ;i<5;i++){
			if(i==2){
				JoinThread jt = new JoinThread("被join的线程");
				//通过 new Thread(target,name).start();  创建线程
				jt.start();
				// main线程调用了jt线程的join 方法，main 线程
				// 必须等jt 执行结束才会向下执行
				jt.join();
			}
			System.out.println(Thread.currentThread().getName()+"、"+i);
		}
	}
}

运行结果：

main、0
main、1
新线程1、0
新线程1、1
新线程1、2
新线程1、3
新线程1、4
被join的线程、0
被join的线程、1
被join的线程、2
被join的线程、3
被join的线程、4
main、2
main、3
main、4

5. 后台线程：他是在后台运行的，任务是为其他线程服务。

特征：如所有的前台线程都死亡了后，后台线程才会消亡。

代码：

package com.zsc.everyday;
// Daemon Thread  后台线程
public class DaemonThread extends Thread{
	// 重写 run 方法，定义线程执行体
	public void run(){
		for(int i=0;i<5;i++){
			//获取线程名称 只能使用  Thread.currentThread().getName()
			System.out.println(Thread.currentThread().getName()+"、"+i);
		}
	}
	public static void main(String[] args) throws Exception {
		DaemonThread t = new DaemonThread();
		//将此线程设置为后台线程
		t.setDaemon(true);
		//启动后台线程
		t.start();
		for(int i =0 ;i<5;i++){
			System.out.println(Thread.currentThread().getName()+"、"+i);
		}
		//程序执行到此处 前台程序（main线程结束）
		//后台线程也随之结束
	}
}

运行结果：

main、0
main、1
main、2
main、3
main、4
Thread-0、0
Thread-0、1
Thread-0、2
Thread-0、3
Thread-0、4

6. 线程睡眠   让当前线程停止一段时间，并进入阻塞状态，则可以调用Thread类的静态方法 sleep();

代码：

package com.zsc.everyday;
import java.sql.Timestamp;
//  线程休眠
public class SleepThread {
	public static void main(String[] args) throws Exception {
		Timestamp start = new Timestamp(System.currentTimeMillis());
		System.out.println(start);
		//线程休眠3秒
		Thread.sleep(3000);
		Timestamp end = new Timestamp(System.currentTimeMillis());
		System.out.println(end);
	}
}

运行结果：

2011-12-23 12:50:57.738
2011-12-23 12:51:00.755