1. 线程的基本知识

1. public class OnlyThread {  
2.     public static void main(String args[]) {  
3.         run(); // 调用静态run()方法  
4.     }  
5.   
6.     /** 
7.      * 实现run()方法 
8.      */  
9.     public static void run() {  
10.         // 循环计算输出的*数目  
11.         for (int count = 1, row = 1; row < 10; row++, count++) {  
12.             for (int i = 0; i < count; i++) { // 循环输出指定的count数目的*  
13.                 System.out.print(‘*‘);   
14.             }  
15.             System.out.println();  
16.         }  
17.     }  
18. }  

1. class ThreadType extends Thread{   
2.      public void run(){   
3.          ……   
4.      }   
5. }   

1. ThreadType  tt = new ThreadType();   

1. tt.start();   

1. void run();   

1. class ThreadDemo1 extends Thread {  
2.     ThreadDemo1() {  
3.     }  
4.   
5.     // 声明ThreadDemo1带参数的构造方法  
6.     ThreadDemo1(String szName) {  
7.         super(szName);  
8.     }  
9.   
10.     // 重载run函数  
11.     public void run() {  
12.         for (int count = 1, row = 1; row < 10; row++, count++) {  
13.             for (int i = 0; i < count; i++) {// 循环输出指定的count数目的*  
14.                 System.out.print(‘*‘);  
15.             }  
16.             System.out.println();  
17.         }  
18.     }  
19.   
20.     public static void main(String argv[]) {  
21.         ThreadDemo1 td = new ThreadDemo1(); // 创建，并初始化ThreadDemo1类型对象td  
22.         td.start(); // 调用start()方法执行一个新的线程  
23.     }  
24. }  

1. public class ThreadDemo2 extends Thread {  
2.     // 声明无参数，空构造方法  
3.     ThreadDemo2() {  
4.     }  
5.   
6.     // 声明带有字符串参数的构造方法  
7.     ThreadDemo2(String szName) {  
8.         super(szName); // 调用父类的构造方法  
9.     }  
10.   
11.     // 重载run函数  
12.     public void run() {  
13.         for (int count = 1, row = 1; row < 10; row++, count++) {  
14.             for (int i = 0; i < count; i++) {// 循环输出指定的count数目的*  
15.                 System.out.print(‘*‘);  
16.             }  
17.             System.out.println();  
18.         }  
19.     }  
20.   
21.     public static void main(String argv[]) {  
22.         ThreadDemo2 td1 = new ThreadDemo2(); // 创建，并初始化ThreadDemo2类型对象td1  
23.         ThreadDemo2 td2 = new ThreadDemo2(); // 创建，并初始化ThreadDemo2类型对象td2  
24.         ThreadDemo2 td3 = new ThreadDemo2(); // 创建，并初始化ThreadDemo2类型对象td3  
25.         td1.start(); // 启动线程td1  
26.         td2.start(); // 启动线程td2  
27.         td3.start(); // 启动线程td3  
28.     }  
29. }  

1. class ThreadType implements Runnable{   
2.      public void run(){   
3.          ……   
4.      }   
5. }   

1. Runnable rb = new ThreadType ();   

1. Thread td = new Thread(rb);   

1. td.start();   

1. class ThreadDemo3 implements Runnable {  
2.     // 重载run函数  
3.     public void run() {  
4.         for (int count = 1, row = 1; row < 10; row++, count++){ // 循环计算输出的*数目  
5.             for (int i = 0; i < count; i++){ // 循环输出指定的count数目的*  
6.                 System.out.print(‘*‘);   
7.             }  
8.             System.out.println();   
9.         }  
10.     }  
11.   
12.     public static void main(String argv[]) {  
13.         Runnable rb = new ThreadDemo3(); // 创建，并初始化ThreadDemo3对象rb  
14.         Thread td = new Thread(rb); // 通过Thread创建线程  
15.         td.start(); // 启动线程td  
16.     }  
17. }  

2. 线程的状态

1. public class  ThreadSleep   
2. {   
3.  public static void main(String[ ] args)    
4.  {   
5.   SubThread st = new SubThread("SubThread");  //创建，并初始化SubThread 对象st   
6.   st.start();         //启动线程st   
7.  }   
8. }   
9.    
10. class SubThread extends Thread{   
11.  SubThread(){}        //声明，实现SubThread无参数构造方法   
12.  //声明，实现SubThread带字符串参数构造方法   
13.  SubThread(String Name)   
14.  {   
15.   super(Name);        //调用父类的构造方法   
16.  }   
17.  //重载run函数   
18.  public void run()   
19.  {   
20.   for (int count = 1,row = 1; row < 10; row++,count++) //循环计算输出的*数目   
21.   {   
22.    for (int i = 0; i < count; i++)      //循环输出指定的count数目的*   
23.    {   
24.     System.out.print(‘*‘);     //输出*   
25.    }   
26.    try         //try-catch块，用于捕获异常   
27.    {     Thread.sleep(1000);     //线程休眠1秒钟   
28.     System.out.print("\t wait........");   
29.    }   
30.    catch (InterruptedException e)    //捕获异常InterruptedException   
31.    {   
32.     e.printStackTrace();     //异常抛出信息   
33.    }   
34.    System.out.println();      //输出换行符   
35.   }   
36.  }   
37. }   

1. 线程1.start();   
2. while(线程 1.isAlive()) {   
3.  Thread.sleep(休眠时间);   
4. }   
5. 线程2.start();   

1. package Test;  
2.   
3. class WaitThreadStop extends Thread {  
4.     // 声明，并实现WaitThreadStop无参数构造方法  
5.     WaitThreadStop() {  
6.     }  
7.   
8.     // 声明，并实现带有一个字符串参数的构造方法  
9.     WaitThreadStop(String szName) {  
10.         super(szName); // 调用父类的构造方法  
11.     }  
12.   
13.     // 重载run函数  
14.     public void run() {  
15.         for (int count = 1, row = 1; row < 10; row++, count++) {  
16.             for (int i = 0; i < count; i++) {  
17.                 System.out.print(‘*‘); // 输出*  
18.             }  
19.             System.out.println(); // 输出换行符  
20.         }  
21.     }  
22. }  
23.   
24. public class WaitThreadStopMain {  
25.     public static void main(String argv[ ]){   
26.       WaitThreadStopMain test = new WaitThreadStopMain();    //创建，初始化WaitThreadStopMain对象test   
27.       test.Method1();  //调用Method1方法   
28.       //test.Method2();   
29.      }  
30.     // 第一种方法：while/isAlive/sleep  
31.     public void Method1() {  
32.         WaitThreadStop th1 = new WaitThreadStop(); // 创建,并初始化WaitThreadStop对象th1  
33.         WaitThreadStop th2 = new WaitThreadStop(); // 创建,并初始化WaitThreadStop对象th2  
34.         // 执行第一个线程  
35.         th1.start();  
36.         // 查询第一个线程的状态  
37.         while (th1.isAlive()) {  
38.             try {  
39.                 Thread.sleep(100); // 休眠100毫秒  
40.             } catch (InterruptedException e) {  
41.                 e.printStackTrace(); // 异常信息输出  
42.             }  
43.         }  
44.         // 当第一个线程终止后，运行第二个线程  
45.         th2.start(); // 启动线程th2  
46.     }  
47.   
48.     // 第二种方法，使用join方法实现等待其他线程结束  
49.     public void Method2() {  
50.         WaitThreadStop th1 = new WaitThreadStop(); // 创建， 并初始化WaitThreadStop对象th1  
51.         WaitThreadStop th2 = new WaitThreadStop(); // 创建，并初始化WaitThreadStop对象th2  
52.         // 执行第一个线程  
53.         th1.start();  
54.         try {  
55.             th1.join(); // th1调用join 方法  
56.         } catch (InterruptedException e) {  
57.             e.printStackTrace(); // 异常信息输出  
58.         }  
59.         // 执行第二个线程  
60.         th2.start();  
61.     }  
62. }  

3. 线程调度

1. class  InheritThread extends Thread {   
2.     //自定义线程的run()方法   
3.     public void run(){   
4.          System.out.println("InheritThread is running…"); //输出字符串信息   
5.          for(int i=0;i<10;i++){   
6.               System.out.println(" InheritThread: i="+i);  //输出信息   
7.               try{   
8.                   Thread.sleep((int)Math.random()*1000); //线程休眠   
9.              }   
10.              catch(InterruptedException e)     //捕获异常   
11.              {}   
12.         }   
13.     }   
14. }   

1. class RunnableThread implements Runnable {  
2.     // 自定义线程的run()方法  
3.     public void run() {  
4.         System.out.println("RunnableThread is running…"); // 输出字符串信息  
5.         for (int i = 0; i < 10; i++) {  
6.             System.out.println("RunnableThread : i=" + i); // 输出i  
7.             try {  
8.                 Thread.sleep((int) Math.random() * 1000); // 线程休眠  
9.             } catch (InterruptedException e) { // 捕获异常  
10.             }  
11.         }  
12.     }  
13. }  
14.   
15. public class ThreadPriority {  
16.     public static void main(String args[]) {  
17.         // 用Thread类的子类创建线程  
18.         InheritThread itd = new InheritThread();  
19.         // 用Runnable接口类的对象创建线程  
20.         Thread rtd = new Thread(new RunnableThread());  
21.         itd.setPriority(5); // 设置myThread1的优先级5  
22.         rtd.setPriority(5); // 设置myThread2的优先级5  
23.         itd.start(); // 启动线程itd  
24.         rtd.start(); // 启动线程rtd  
25.     }  
26. }  

4. 线程同步

1. //文件：程序ThreadNoSynchronized.java   描述：多线程不同步的原因   
2. class ShareData {  
3.     public static String szData = ""; // 声明，并初始化字符串数据域，作为共享数据  
4.   
5. }  
6. class ThreadDemo extends Thread {  
7.     private ShareData oShare; // 声明，并初始化ShareData 数据域  
8.     ThreadDemo() {  
9.     } // 声明，并实现ThreadDemo 构造方法  
10.   
11.     // 声明，并实现ThreadDemo 带参数的构造方法  
12.     ThreadDemo(String szName, ShareData oShare) {  
13.         super(szName); // 调用父类的构造方法  
14.         this.oShare = oShare; // 初始化oShare域  
15.     }  
16.     public void run() {  
17.         for (int i = 0; i < 5; i++) {  
18.             if (this.getName().equals("Thread1")) {  
19.                 oShare.szData = "这是第 1 个线程";  
20.                 // 为了演示产生的问题，这里设置一次睡眠  
21.                 try {  
22.                     Thread.sleep((int) Math.random() * 100); // 休眠  
23.                 } catch (InterruptedException e) { // 捕获异常  
24.                 }  
25.                 System.out.println(this.getName() + ":" + oShare.szData); // 输出字符串信息  
26.             } else if (this.getName().equals("Thread2")) {  
27.                 oShare.szData = "这是第 2 个线程";  
28.                 // 为了演示产生的问题，这里设置一次睡眠  
29.                 try {  
30.                     Thread.sleep((int) Math.random() * 100); // 线程休眠  
31.                 } catch (InterruptedException e) // 捕获异常  
32.                 {  
33.                 }  
34.                 System.out.println(this.getName() + ":" + oShare.szData); // 输出字符串信息  
35.             }  
36.         }  
37.     }  
38. }  
39.   
40. public class ThreadNoSynchronized {  
41.     public static void main(String argv[]) {  
42.         ShareData oShare = new ShareData(); // 创建，初始化ShareData对象oShare  
43.         ThreadDemo th1 = new ThreadDemo("Thread1", oShare); // 创建线程th1  
44.         ThreadDemo th2 = new ThreadDemo("Thread2", oShare); // 创建线程th2  
45.         th1.start(); // 启动线程th1  
46.         th2.start(); // 启动线程th2  
47.     }  
48. }  

1. class 类名{   
2.      public synchonized 类型名称 方法名称(){   
3.            ......   
4.      }   
5. }   

1. synchornized(obj)   
2. {    
3.   //………………….    
4. }   

1. public void method()   
2. {    
3.   Object obj= new Object(); //创建局部Object类型对象obj   
4.   synchornized(obj)   //同步块   
5.   {   
6.       //……………..    
7.   }    
8. }    

1. class method   
2. {    
3.     Object o = new Object();  //创建Object类型的成员变量o   
4. public void test()   
5. {    
6. synchornized(o)  //同步块   
7. {    
8.             //………………………   
9.         }    
10.     }    
11. }   

1. public void method()   
2. {    
3. synchornized(this)  //同步块   
4. {    
5.     //………………………   
6.     }    
7. }   

1. synchornized(ClassName.class)   
2. {    
3.     //…………………….   
4. }   

5. 线程通信

1. class Producer extends Thread {  
2.     Queue q;  
3.   
4.     Producer(Queue q) {  
5.         this.q = q;  
6.     }  
7.     public void run() {  
8.         for (int i = 1; i < 5; i++) {  
9.             q.put(i);  
10.         }  
11.     }  
12. }  
13.   
14. class Consumer extends Thread {  
15.     Queue q; // 声明队列q  
16.     Consumer(Queue q){   
17.         this.q = q; // 队列q初始化  
18.     }  
19.     public void run() {  
20.         while (true) {// 循环消费元素  
21.             q.get(); // 获取队列中的元素  
22.         }  
23.     }  
24. }  

1. class Queue {  
2.     int value = 0; // 声明，并初始化整数类型数据域value  
3.     boolean isEmpty = true; // 声明，并初始化布尔类型数据域isEmpty，用于判断队列的状态  
4.   
5.     // 生产者生产方法  
6.     public synchronized void put(int v) {  
7.         // 如果共享数据没有被消费，则生产者等待  
8.         if (!isEmpty) {  
9.             try {  
10.                 System.out.println("生产者等待");  
11.                 wait(); // 进入等待状态  
12.             } catch (Exception e) // 捕获异常  
13.             {  
14.                 e.printStackTrace(); // 异常信息输出  
15.             }  
16.         }  
17.         value += v; // value值加v  
18.         isEmpty = false; // isEmpty赋值为false  
19.         System.out.println("生产者共生产数量：" + v);  
20.         notify();  
21.     }  
22.   
23.     public synchronized int get() {  
24.         if (isEmpty) {  
25.             try {  
26.                 System.out.println("消费者等待");  
27.                 wait();  
28.             } catch (Exception e) {  
29.                 e.printStackTrace();  
30.             }  
31.         }  
32.         value--;  
33.         if (value < 1) {  
34.   
35.             isEmpty = true;  
36.         }  
37.         System.out.println("消费者消费一个，剩余：" + value);  
38.         notify();  
39.         return value;  
40.     }  
41. }  

1. public class ThreadCommunication {  
2.     public static void main(String[] args) {  
3.         Queue q = new Queue();  
4.         Producer p = new Producer(q);  
5.         Consumer c = new Consumer(q);  
6.         c.start();  
7.         p.start();  
8.     }  
9. }  

6. 线程死锁

1. public class ThreadLocked implements Runnable {  
2.     public static boolean flag = true; // 起一个标志作用  
3.     private static Object A = new Object(); // 声明，并初始化静态Object数据域A  
4.   
5.     private static Object B = new Object(); // 声明，并初始化静态Object数据域B  
6.   
7.     public static void main(String[] args) throws InterruptedException {  
8.         Runnable r1 = new ThreadLocked(); // 创建，并初始化ThreadLocked对象r1  
9.         Thread t1 = new Thread(r1); // 创建线程t1  
10.         Runnable r2 = new ThreadLocked(); // 创建，并初始化ThreadLocked对象r2  
11.         Thread t2 = new Thread(r2); // 创建线程t2  
12.         t1.start(); // 启动线程t1  
13.         t2.start(); // 启动线程t2  
14.     }  
15.   
16.     public void AccessA() {  
17.         flag = false; // 初始化域flag  
18.         // 同步代码快  
19.         synchronized (A) { // 声明同步块，给对象A加锁  
20.             System.out.println("线程t1 : 我得到了A的锁"); // 输出字符串信息  
21.             try {  
22.                 // 让当前线程睡眠,从而让另外一个线程可以先得到对象B的锁  
23.                 Thread.sleep(1000); // 休眠  
24.             } catch (InterruptedException e) { // 捕获异常  
25.                 e.printStackTrace(); // 异常信息输出  
26.             }  
27.             System.out.println("线程t1 : 我还想要得到B的锁");  
28.             // 在得到A锁之后,又想得到B的锁  
29.             // 同步块内部嵌套同步块  
30.             synchronized (B) { // 声明内部嵌套同步块，指定对象B的锁  
31.                 System.out.println("线程t1 : 我得到了B的锁"); // 输出字符串信息  
32.             }  
33.         }  
34.     }  
35.   
36.     public void AccessB() {  
37.         flag = true; // 修改flag的值  
38.         // 同步代码块  
39.         synchronized (B) { // 指定同步块，给B加锁  
40.             System.out.println("线程t2 : 我得到了B的锁"); // 输出字符串信息  
41.             try {  
42.                 // 让当前线程睡眠,从而让另外一个线程可以先得到对象A的锁  
43.                 Thread.sleep(1000); // 休眠  
44.             } catch (InterruptedException e) { // 捕获异常InterruptedException  
45.                 e.printStackTrace(); // 异常信息输出  
46.             }  
47.             System.out.println("线程t2 : 我还想要得到A的锁"); // 字符串信息输出  
48.             // 在得到B锁之后,又想得到A的锁  
49.             // 同步块内部嵌套内部快  
50.             synchronized (A) { // 指定同步块，给A加锁  
51.                 System.out.println("线程t2 : 我得到了A的锁"); // 输出字符串信息  
52.             }  
53.         }  
54.     }  
55.   
56.     public void run() {  
57.         if (flag){ // 当flag为true，执行下面语句  
58.             AccessA(); // 调用AccessA方法  
59.         } else {  
60.             AccessB(); // 调用AccessB方法  
61.         }  
62.     }  
63.   
64. }