5.JAVA语言基础部分—多线程

一个应用有一个进程，一个进程里可以用多个线程

1）定义

定义线程有两种方式，一是继承java.lang.Thread类，二是实现java.lang.Runnable接口。其实Thread类就是实现了Runnable接口的。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

//方法一：继承Thread,并重写run() public class OrdersThread extends Thread {     //该类实例化时并不会立即执行run（），而是在实例上调用start()才会执行     @Override     public void run() {         //需要线程执行的内容放在run方法         for (int i = 0; i < 10; i++) {             System.out.println(i);         }     } }    //调用     public static void main(String[] args) {         OrdersThread ot=new OrdersThread();         //调用start()才真正开始线程         ot.start();     }

方法二:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

//方法二实现接口Runnable public class MyRunnable implements Runnable{       @Override     public void run() {         // 这里放需要执行的代码     } }   // 调用     public static void main(String[] args) {         MyRunnable ta = new MyRunnable();         //通过实现Runnable接口方式，需要使用Thread实现来启动         Thread thread1 = new Thread(ta);         thread1.start();     }

方法三：Runnable方式还可以通过匿名类的写法实现

?

1 2 3 4 5 6 7 8 9

public static void main(String[] args) {         //匿名类实现的方式，匿名类实现接口Runnable         Thread thread2=new Thread(new Runnable() {             @Override             public void run() {                 //需要执行的代码             }         });     }

 

2）线程生命周期

Thread.sleep(毫秒值):进入休眠，单位毫秒。线程不会释放对象锁，不让出系统资源，占用着。直接使用Thread类调用sleep,不用实例。谁调用谁睡觉去，即使在当前线程调用别的线程的sleep,睡觉的不是当前线程，其他线程不受影响。sleep的唤醒要等时间到了自动醒过来，如果时间不到只能调用它的实例的interrupt()强行中断。

wait():也是等待，一般不需要指定时间，需要使用notify()/notifyAll()来唤醒。它跟sleep不同，wait是释放对象锁的，不占资源，一般是用到同步模块（synchronized）中去。如下面所示，也有多线程同步的写法；

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

public class MyRunnable implements Runnable {   private static String flag="";     @Override     public void run() {         //多线程同步         //这里可以定义一个变量，或者使用当前类this,或空格“” 都可以         synchronized (flag) {             //这里notify()是唤醒当前MyRunnable的上一个实例继承执行(上次实例中wait()后面的代码继承执行)             //这里notifyAll()是唤醒当前MyRunnable的【所有所有所有】实例中有wait()的实例继承执行             //只能在当前的run调用notity,其它地方行             flag.notify();                           for (int i = 1000; i < 1100; i++) {                 if (i == 1050) {                     try {                         System.out.println("MyRunnable暂停了");                         flag.wait();                     } catch (InterruptedException e) {                         e.printStackTrace();                     }                 }                 System.out.println(i);             }         }     } }

3）线程加入

有两个线程A、B，在执行A时某一步骤时要先让B执行完后再继续执行A，可以使用join()

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

package com.test;   import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.util.ArrayList; import java.lang.reflect.*;   public class Main {     //定义未赋值的变量放在外面      private static Thread a;      private static Thread b;     public static void main(String[] args) {             a = new Thread(new Runnable() {             public void run() {                 for (int i = 10; i < 20; i++) {                     try {                         Thread.sleep(100);                         print(i);                         if (i == 12) {                             //到此处时，只有b完成后才会继续往下走                             b.join();                         }                     } catch (InterruptedException e) {                         e.printStackTrace();                     }                 }             }         });         a.start();                b = new Thread(new Runnable() {             public void run() {                 for (int i = 30; i < 40; i++) {                     try {                         Thread.sleep(100);                     } catch (InterruptedException e) {                         e.printStackTrace();                     }                     print(i);                 }             }         });         b.start();     } }

4)线程中断

方法一：在线程继承类或实现Runnable接口的类里定义一个变量，然后在run()处判断该变量值为多少时就使用break；退出。该方法有限制，当线程里使用了sleep()或wait()后就无法退出了，此时应使用方法interrup()退出。

方法二：强行中断线程使用interrup(),调用线程的实例的interrup()方法，线程执行处就会抛出异常InterruptedException，使用try catch捕获使用break退出即可。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class OrdersThread extends Thread {     @Override     public void run() {         for (int i = 0; i < 10; i++) {              if(i==5)                 try {                     Thread.sleep(1000);                 } catch (InterruptedException e) {                     //只要在run()里使用try catch捕获InterruptedException异常，然后使用break处理并退出了                     System.out.println("强行退出了");                     break;                 }             System.out.println(i);         }     } }

 

?

1 2 3

OrdersThread t3=new OrdersThread();         t3.start();         t3.interrupt();//实例里强行退出

5）线程优先线

线程优先级有常数:1-10,默认为5

使用setPriority(1~10的整数)

?

1 2 3 4 5 6 7 8 9

OrdersThread t3=new OrdersThread();         //注意值的范围是1-8         t3.setPriority(8);         //也可以使用预先定义的枚举指定         //t3.setPriority(Thread.NORM_PRIORITY);         t3.setName("线程名称");//这里设置线程名称的写法         //最后才能start         t3.start();

6）线程同步

?

1 2 3 4 5 6 7 8 9 10 11 12 13

public class MyRunnable implements Runnable {     @Override     public void run() {         // Object可以是任何，一般是定义一个静态变量，或者当前类实例         synchronized (Object) {             // 需要步的代码             for (int i = 1000; i < 1100; i++) {                 System.out.println(i);             }         }       } }

线程同步方法

?

1 2 3 4

//同步方法使用synchronized修饰     public  synchronized String getName() {         return "";     }