Java中Thread的常用方法

 1 /*
 2  *Thread常用方法
 3  *1.start():启动当前的线程，调用当前线程的run()
 4  *2.run():通常需要重写Thread类中的此方法，将创建要执行的操作声明在此方法中
 5  *3.currentThread():静态方法，返回代码执行的线程
 6  *4.getName():获取当前线程的名字
 7  *5.setName():设置当前线程的名字
 8  *6.yield():释放当前CPU的执行
 9  *7.join():在线程a中调用线程b的join()方法,此时线程a进入阻塞状态
10  *8.stop():已过时的方法，当执行此方法是，强制结束当前进程
11  *9.sleep(long millitime):让当前进程睡眠指定的毫秒数，在指定时间内，线程是阻塞状态
12  *10.isAlive():判断进程是否存活
13  */
14 class HelloThread extends Thread
15 {
16     public void run()
17     {
18         for(int i=1;i<20;i++)
19         {
20             if((i&1)==0)
21             {/*
22             sleep()，是静态的可以直接通过类调用，会抛异常
23             HelloThread是继承在Thread里的，在Thread里run()没有抛异常（子类重写方法抛出的异常<=父类被重写异常抛出的方法），
24             所以此处不可以throws，只能用try-catch
25             */
26                 try {
27                     sleep(1000);//阻塞1000ms，即1s
28                 } catch (InterruptedException e) {
29                     // TODO Auto-generated catch block
30                     e.printStackTrace();
31                 }
32                 //在1s阻塞后，等CPU分配资源再运行主程序
33                 System.out.println(Thread.currentThread().getName()+":"+i);
34             }
35             if(i%10==0)
36             {
37                 this.yield();
38             }
39         }
40     }
41     /*在源码中可以看到 Thread有对于名字命名的构造器
42      * public Thread(String name) {
43      *    init(null, null, name, 0);
44      * }
45      * 所以子类继承父类的构造器就行
46      */
47     /*
48     public HelloThread(String name)
49     {
50         super(name);
51     }
52     */
53 }
54 public class test{
55     public static void main(String[] args) {
56         //给线程命名方法1 调用setName()
57         HelloThread h1=new HelloThread();
58         HelloThread h2=new HelloThread();
59         h1.setName("*1*");
60         h2.setName("*2*");
61         h1.start();
62         h2.start();
63         //给线程命名方法2 建立类对象，调用构造器
64         /*
65          *HelloThread h2=new HelloTHread("*2*"); 
66          */
67         //给主线程命名
68         Thread.currentThread().setName("主线程");
69         for(int i=0;i<20;i++)
70         {
71             if((i&1)==1)
72             {
73                 System.out.println(Thread.currentThread().getName()+":"+i);
74             }
75             if(i==10)
76             {
77                 try {//主线程中调用h1的join()方法，此时主线程进入阻塞状态
78                     h1.join();//join是Thread中的方法，不是该类中的方法，只能通过继承Thread类的子类对象调用
79                 } catch (InterruptedException e) {
80                     // TODO Auto-generated catch block
81                     e.printStackTrace();
82                 }
83             }
84         }
85     }
86 }

通过上述学习的方法，我们来完成一个具体的例子。

创建三个窗口共卖100张票。（暂时忽略线程不安全即出现重票现象）

1.通过类继承Thread实现

 1 //创建三个窗口共卖100张票
 2 
 3 class Window extends Thread
 4 {
 5     private static int ticket=100;
 6     public void run()
 7     {
 8         while(true)
 9         {
10             if(ticket>0)
11             {
12                 System.out.println(getName()+":卖票，票号为："+ticket);
13                 ticket--;
14             }
15             else
16                 break;
17         }
18     }
19 }
20 public class test
21 {
22     public static void main(String[] args)
23     {
24         Window t1=new Window();
25         Window t2=new Window();
26         Window t3=new Window();
27         t1.setName("*1*");
28         t2.setName("*2*");
29         t3.setName("*3*");
30         t1.start();
31         t2.start();
32         t3.start();
33     }
34 }

2.通过类调用接口实现

 1 //创建三个窗口共卖100张票
 2 class Window implements Runnable
 3 {
 4     private int ticket=100;
 5     public void run()
 6     {
 7         while(true)
 8         {
 9             if(ticket>0)
10             {
11                 System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
12                 ticket--;
13             }
14             else
15                 break;
16         }
17     }
18 }
19 public class test{
20     public static void main(String[] args) {
21         Window w=new Window();//因为只造了一个Window类对象，3个线程公用一个进程，所以不用把ticket声明为静态的
22         Thread t1=new Thread(w);
23         Thread t2=new Thread(w);
24         Thread t3=new Thread(w);
25         t1.setName("1");
26         t1.setName("2");
27         t1.setName("3");
28         t1.start();
29         t2.start();
30         t3.start();
31     }
32 }