java创建启动多线程的三种方式

java创建启动多线程的三种方式

标签： java多线程thread

2013-10-24 11:08 1503人阅读 评论(0) 收藏 举报

本文章已收录于：

分类：

java（20）

作者同类文章 X

版权声明：本文为博主原创文章，未经博主允许不得转载。

线程的创建和启动 

  java使用Thread代表线程，所有的对象都是Thread类或其之类的实例

使用继承Tread类来启动多线程的基本步骤:

  1.创建Thread类的子类，并重写run()方法，该方法代表了该线程完成的任务。run方法为线程执行体。

  2.创建Thread类子类的实例，即创建了线程的对象。

  3.调用线程的start()方法来启动线程。

• 欢迎加入QQ交流3群：317874559

[java] view plain copy print ?

1. package com.java.xiong.Tread16;  
2.   
3.   
4. public class ss extends Thread {  
5.       
6.     //重新run方法  
7.         @Override  
8.         public void run() {  
9.               
10.             for(int i=0;i<100;i++){  
11.                 //当前线程  
12.                 System.out.println("线程名"+i+":"+this.getName());  
13.             }  
14.         }  
15.         //启动主线程main  
16.     public static void main(String []arg){  
17.         for(int i=0;i<100;i++){  
18.             //当前线程  
19.             System.out.println(Thread.currentThread().getName());  
20.             if(i==10)  
21.             {  
22.                 //启动第一个线程  
23.                 new ss().start();  
24.                 //启动第二个线程  
25.                 new ss().start();  
26.             }  
27.         }  
28.     }  
29.   
30. }  

package com.java.xiong.Tread16;


public class ss extends Thread {
	
	//重新run方法
		@Override
		public void run() {
			
			for(int i=0;i<100;i++){
				//当前线程
				System.out.println("线程名"+i+":"+this.getName());
			}
		}
		//启动主线程main
	public static void main(String []arg){
		for(int i=0;i<100;i++){
			//当前线程
			System.out.println(Thread.currentThread().getName());
			if(i==10)
			{
				//启动第一个线程
				new ss().start();
				//启动第二个线程
				new ss().start();
			}
		}
	}

}

使用Runnable接口来创建并启动线程的步骤

   1.定义Runnable接口的实现类，并重写该接口的run()方法；run()方法则为该线程的执行体

    2.创建Runnable接口实现类的实例

    3.实例化Thread类，参数为Runnable接口实现类的对象(Thread类的对象才是正在的线程对象)来启动线程

[java] view plain copy print ?

1. package com.java.xiong.Tread16;  
2.   
3. //创建线程对象  
4. public class RunnableTread implements Runnable {  
5.   
6.     @Override  
7.     public void run() {  
8.   
9.         for (int i = 0; i < 100; i++) {  
10.             // 当前线程  
11.             System.out.println("线程名" + i + ":"  
12.                     + Thread.currentThread().getName());  
13.         }  
14.   
15.     }  
16.   
17. }  

package com.java.xiong.Tread16;

//创建线程对象
public class RunnableTread implements Runnable {

	@Override
	public void run() {

		for (int i = 0; i < 100; i++) {
			// 当前线程
			System.out.println("线程名" + i + ":"
					+ Thread.currentThread().getName());
		}

	}

}

[java] view plain copy print ?

1. package com.java.xiong.Tread16;  
2.   
3. public class RunnableTest {  
4.   
5.     public static void main() {  
6.           
7.         RunnableTread runs=new RunnableTread();  
8.         //获取线程对象  
9.         Thread tr=new Thread(runs);  
10.         for (int i = 0; i < 100; i++) {  
11.             // 当前线程  
12.             System.out.println(Thread.currentThread().getName());  
13.             if (i == 10) {  
14.                 // 启动第一个线程  
15.                 tr.start();  
16.                 // 启动第二个线程  
17.                 tr.start();  
18.             }  
19.         }  
20.     }  
21. }  

package com.java.xiong.Tread16;

public class RunnableTest {

	public static void main() {
		
		RunnableTread runs=new RunnableTread();
		//获取线程对象
		Thread tr=new Thread(runs);
		for (int i = 0; i < 100; i++) {
			// 当前线程
			System.out.println(Thread.currentThread().getName());
			if (i == 10) {
				// 启动第一个线程
				tr.start();
				// 启动第二个线程
				tr.start();
			}
		}
	}
}

使用Callable与Future来创建启动线程

  1.创建Callable的实现类,并冲写call()方法，该方法为线程执行体，并且该方法有返回值

  2.创建Callable的实例，并用FutuerTask类来包装Callable对象，该FutuerTask封装了Callable对象call()方法的返回值

  3.实例化FutuerTask类，参数为FutuerTask接口实现类的对象来启动线程

  4.通过FutuerTask类的对象的get()方法来获取线程结束后的返回值

[java] view plain copy print ?

1. package com.java.xiong.Tread16;  
2.   
3. import java.util.concurrent.Callable;  
4. import java.util.concurrent.FutureTask;  
5.   
6. public class CallableTest implements Callable<Integer> {  
7.   
8.     @Override  
9.     public Integer call() throws Exception {  
10.         // TODO Auto-generated method stub  
11.   
12.         int i = 0;  
13.         for (; i < 100; i++) {  
14.             // 当前线程  
15.             System.out.println("线程名" + i + ":" + Thread.currentThread());  
16.         }  
17.         return i;  
18.     }  
19.   
20.     public static void main(String[] args) {  
21.         CallableTest call = new CallableTest();  
22.         FutureTask<Integer> fu = new FutureTask<Integer>(call);  
23.         Thread th = new Thread(fu, "有返回值的线程");  
24.   
25.         for (int i = 0; i < 100; i++) {  
26.             // 当前线程  
27.             System.out.println(Thread.currentThread().getName());  
28.             if (i == 10) {  
29.                 // 启动第一个线程  
30.                 th.start();  
31.             }  
32.         }  
33.         try {  
34.             System.out.println("返回值是:" + fu.get());  
35.   
36.         } catch (Exception e) {  
37.             e.printStackTrace();  
38.         }  
39.     }  
40.   
41. }  

package com.java.xiong.Tread16;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableTest implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub

		int i = 0;
		for (; i < 100; i++) {
			// 当前线程
			System.out.println("线程名" + i + ":" + Thread.currentThread());
		}
		return i;
	}

	public static void main(String[] args) {
		CallableTest call = new CallableTest();
		FutureTask<Integer> fu = new FutureTask<Integer>(call);
		Thread th = new Thread(fu, "有返回值的线程");

		for (int i = 0; i < 100; i++) {
			// 当前线程
			System.out.println(Thread.currentThread().getName());
			if (i == 10) {
				// 启动第一个线程
				th.start();
			}
		}
		try {
			System.out.println("返回值是:" + fu.get());

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}