初探多线程之线程

Thread类和Runnable接口，Callable接口的区别：

/**
 * 继承thread类来生成线程 线程不共享资源
 * 
 * @author Administrator
 * 
 */
public class HelloThread extends Thread {
	private int count = 5;

	public void run() {
		for (int i = 0; i < 5; i++) {
			if (count > 0) {
				System.out.println("count= " + count--);
			}
		}
	}

	public static void main(String[] args) {
		HelloThread thread1 = new HelloThread();
		HelloThread thread2 = new HelloThread();
		HelloThread thread3 = new HelloThread();
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

 运行结果：

count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1

 

/**
 * 实现runnable接口生成线程对象
 * 对象共享资源
 * runnable是代理目标对象
 * @author Administrator
 *
 */
public class HelloRunnable implements Runnable{
	private int count = 5;
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			if (count > 0) {
				System.out.println("count= " + count--);
			}
		}

	}
	
	public static void main(String[] args) {
		HelloRunnable helloRunnable = new HelloRunnable();
		new Thread(helloRunnable).start();
		new Thread(helloRunnable).start();
		new Thread(helloRunnable).start();
	}
}

 运行结果：

count= 5
count= 3
count= 4
count= 1
count= 2

 

/**
 * jdk1.5后新加的函数
 * @author Administrator
 *
 */
public class CallableTest implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int i = 0;
		for(; i < 10; i++){
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
		return i;
	}
	
	public static void main(String[] args) {
		CallableTest callableTest = new CallableTest();
		FutureTask<Integer> futureTask = new FutureTask<Integer>(callableTest);
		new Thread(futureTask).start();
	}
}

 运行结果:

Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
Thread-0 9

 

总结：

实现Runnable接口和Callable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

 

判断线程是否启动：

/**
 * 判断线程是否启动
 * @author Administrator
 *
 */
public class StartThreadTest implements Runnable{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName());
	}
	
	
	public static void main(String[] args) {
		StartThreadTest startThreadTest = new StartThreadTest();
		Thread thread = new Thread(startThreadTest, "线程1");
		System.out.println("线程是否启动：" + thread.isAlive());
		thread.start();
		System.out.println("线程是否启动：" + thread.isAlive());
	}
}	

 运行结果：

 线程是否启动：false
 线程是否启动：true
 线程1

线程强行执行（join方法）：

 

/**
 * thread强行在main主线程中执行
 * 直到thread执行完后，main主线程才开始执行。
 * 可将大问题分成小问题的思想
 * @author Administrator
 *
 */
public class JoinTest implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + i);
		}
	}

	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			if (i == 5) {
				JoinTest joinTest = new JoinTest();
				Thread thread = new Thread(joinTest, "线程1");
				thread.start();
				thread.join();
			}
			System.out.println("main主线程" + i);
		}
		
	}

}

 运行结果：

main主线程0
main主线程1
main主线程2
main主线程3
main主线程4
线程10
线程11
线程12
线程13
线程14
线程15
线程16
线程17
线程18
线程19
main主线程5
main主线程6
main主线程7
main主线程8
main主线程9

 

 线程的中断：

 

/**
 * 如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞， 
 * 那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。
 * 
 * 如果线程没有被阻塞，这时调用interrupt()将不起作用
 * @author Administrator
 *
 */
public class ThreadInterupt implements Runnable{

	@Override
	public void run() {
		for(int i = 0; i < 10; i++){
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				System.out.println("线程被中断");
			}
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		ThreadInterupt interupt = new ThreadInterupt();
		Thread thread = new Thread(interupt);
		thread.start();
		
		thread.interrupt();
	}
}

 后台线程（Daemon Thread）:

  JVM的垃圾回收线程就是典型的后台线程，特征：如果所有的前台线程都死亡，后台线程会自动死亡。

 

/**
 * 后台线程的使用
 * @author Administrator
 *
 */
public class DaemonThread extends Thread{
	public void run(){
		for(int i = 0; i < 100; i++){
			System.out.println(this.getName() + "" + i);
		}
	}
	
	public static void main(String[] args) throws Exception{
		DaemonThread dt = new DaemonThread();
		//设定为后台线程
		dt.setDaemon(true);
		dt.start();
		for(int i = 0; i < 10; i++){
			System.out.println(Thread.currentThread().getName() + "" + i);
		}
	}
}

 运行结果：

main0
main1
main2
Thread-00
main3
main4
Thread-01
Thread-02
Thread-03

 

线程的休眠：

 

/**
 * 线程休眠
 * @author Administrator
 *
 */
public class ThreadSleep implements Runnable{

	@Override
	public void run() {
		for(int i = 0; i < 3; i++){
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		ThreadSleep sleep = new ThreadSleep();
		new Thread(sleep).start();
	}

}

 

 

线程的让步（yield方法）：

 

public class YieldTest extends Thread{
	public YieldTest(String name){
		super(name);
	}
	
	public void run(){
		for(int i = 0; i < 20; i++){
			System.out.println(getName() + "" + i);
			
			if(i == 5){
				Thread.yield();
			}
		}
	}
	
	public static void main(String[] args) {
		YieldTest yt1 = new YieldTest("高级");
		yt1.setPriority(MAX_PRIORITY);
		yt1.start();
		
		YieldTest yt2 = new YieldTest("低级");
		yt2.setPriority(MIN_PRIORITY);
		yt2.start();
	}
}

 

  sleep()方法和yield()方法的区别：

   1）sleep()方法暂停当前线程后，会给其他线程执行的机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。

   2）sleep()方法会将线程转入阻塞状态，直到经过指定阻塞时间后才转入就绪状态；yield()不会将线程转入阻塞状态，而是强制当前线程进入就绪状态。

   3）sleep()方法声明抛出InterruptedException异常，而yield()方法没有抛出任何异常。

   4）sleep()方法可移植性好于yield()方法，所以不建议用yield()方法控制并发线程的执行。

 

线程的优先级：

   1.MAX_PRIORITY : 10

   2.MIN_PRIORITY:1

   3.NORM_PRIORITY:5

   可通过setsetPriority(MIN_PRIORITY)指定优先级。