java.lang.Thread(1)

Create Thread

java线程的两种实现方式

·继承Thread类

·实现Runnable接口

1、继承Thread类

定义语法：

　　　　　　　　　　　class classname extends Thread{
           　　　　　　　　　　　　　 属性;
            　　　　　　　　　　　　　方法;
           　　　　　　　　　　　　　 //覆写Thread类中run()
            　　　　　　　　　　　　public void run(){
                  　　　　　　　　 }
          　　　　　　　　　　　}

　　
　　　　　　例如：　　　　

　　　　　　　　　　　class PrimeThread extends Thread {
        　　　　　　　　　　　　　　　　 long minPrime;
         　　　　　　　　　　　　　　　　PrimeThread(long minPrime) {
             　　　　　　　　　　　　　　　　　　this.minPrime = minPrime;
         　　　　　　　　　　　　　　　　　　}
         　　　　　　　　　　　　　　　　public void run() {
            　　　　　　　　　　　　　　 // compute primes larger than minPrime
              　　　　　　　　　　　　　　. . .
         　　　　　　　　　　　　　　　　}
    　　　　　　　　　　　　　　　　 }

　　　　　　启动线程：　　　

　　　　　　　　　　　　PrimeThread p = new PrimeThread(143);
     　　　　　　　　　p.start();

　　　　　　详细示例1：

View Code

 1 //用继承Thread创建线程
 2 public class CreateThreadExtendsThread02 {
 3     public static void main(String[] args) {
 4         MyThread myA = new MyThread("线程A");
 5         MyThread myB = new MyThread("线程B");
 6         MyThread myC = new MyThread("线程C");
 7         myA.start();
 8         myB.start();
 9         myC.start();
10     }
11 }
12 
13 class MyThread extends Thread{
14     private String name;
15     public MyThread(String name){
16         this.name = name;
17     }
18     public void run(){
19         for(int i=1;i<=20;i++)
20             System.out.println(i+ " "+this.name);
21     }
22 }

　　　　　　详细示例2：

View Code

 1 //用继承Thread创建线程
 2 //线程A：打印A 100个
 3 //线程B：打印B 100个
 4 //线程100：打印1-100
 5 
 6 public class CreateThreadExtendsThread {
 7     public static void main(String[] args) {
 8          PrintChar pc1 = new PrintChar('A',100);
 9          PrintChar pc2 = new PrintChar('B',100);
10          PrintNumber pn = new PrintNumber(100);
11         //创建任务线程
12         Thread thread1 = new Thread(pc1);
13         Thread thread2 = new Thread(pc2);
14         Thread thread3 = new Thread(pn);
15         //启动线程
16         thread1.start();
17         thread2.start();
18         thread3.start();
19     }
20 }
21 
22 class PrintCharacter extends Thread{
23     private char ch;
24     private int number;
25     
26     public PrintCharacter(char ch,int number){
27         this.ch = ch;
28         this.number = number;        
29     }
30     
31     public void run(){
32         for(int i=1;i<=number;i++)
33             System.out.print(" "+ch);
34     }
35 }
36 
37 class PrintNum extends Thread{
38     private int number;
39     
40     public PrintNum(int number){
41         this.number = number;        
42     }
43     
44     public void run(){
45         for(int i=1;i<=number;i++)
46             System.out.print(" "+i);
47     }
48 }

2、实现Runnable接口

　　　　　　定义一个类，实现Runnable接口，并覆盖 run()方法，在这个方法里是你希望这个线程运行的代码。

　　　　　　创建一个这个新类的对象。

　　　　　　创建一个Thread类的对象，用刚才的Runnable对象作为构造函数参数。

　　　　　　调用Thread对象的start()方法来启动线程。

　　　　　　定义语法：

　　　　　　　　　　　　class classname implements Runnable{
            　　　　　　　　　　　　　　属性;
           　　　　　　　　　　　　　　 方法;
            　　　　　　　　　　　　　　//覆写Runnable类中run()
           　　　　　　　　　　　　　　 public void run(){
　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}

　　　　　　例如：

　　　　　　　　　　　　class PrimeRun implements Runnable {
        　　　　　　　　　　　　　　　　long minPrime;
         　　　　　　　　　　　　　　　 PrimeRun(long minPrime) {
             　　　　　　　　　　　　　　　　this.minPrime = minPrime;
         　　　　　　　　　　　　　　　 }
        　　　　　　　　　　　　　　　　 public void run() {
             　　　　　　　　　　　　　　　　　// compute primes larger than minPrime
            　　　　　　　　　　　　　　　　　　  . . .
        　　　　　　　　　　　　　　　　 }
     　　　　　　　　　　}

　　　　　　启动线程：

  　　　　　　　　　　PrimeRun p = new PrimeRun(143);
   　　　　　　　　　 new Thread(p).start();

　　　　　　详细示例：

View Code

 1 //用实现Runnable接口创建线程
 2 //线程A：打印A 100个
 3 //线程B：打印B 100个
 4 //线程100：打印1-100
 5 public class CreateThreadImplementRunnable {
 6     public static void main(String[] args) {
 7         //用实现Runnable接口
 8          /*Runnable pc1 = new PrintChar('A',100);
 9          Runnable pc2 = new PrintChar('B',100);
10          Runnable pn = new PrintNumber(100);
11 */
12          PrintChar pc1 = new PrintChar('A',100);
13          PrintChar pc2 = new PrintChar('B',100);
14          PrintNumber pn = new PrintNumber(100);
15             
16         //创建任务线程
17         Thread thread1 = new Thread(pc1);
18         Thread thread2 = new Thread(pc2);
19         Thread thread3 = new Thread(pn);
20         //启动线程
21         thread1.start();
22         thread2.start();
23         thread3.start();
24     }
25 }
26 
27 class PrintChar implements Runnable{
28     private char ch;
29     private int number;
30     
31     public PrintChar(char ch,int number){
32         this.ch = ch;
33         this.number = number;        
34     }
35     
36     public void run(){
37         for(int i=1;i<=number;i++)
38             System.out.print(" "+ch);
39     }
40 }
41 
42 class PrintNumber implements Runnable{
43     private int number;
44     
45     public PrintNumber(int number){
46         this.number = number;        
47     }
48     
49     public void run(){
50         for(int i=1;i<=number;i++)
51             System.out.print(" "+i);
52     }
53 }