java线程理解002

本章节主要是学习一种新的创建线程的方法，熟悉线程的常用方法，线程同步。

 

1. 利用实现Runnable接口创建一个新的线程。

    1 package interThread_v001;
    2 
    3 public class Runable_v001 implements Runnable
    4 
    5 {
    6     // 线程体
    7 
    8     public void run()
    9 
   10     {
   11         for(int i=0; i<100; i++)
   12         {
   13 
   14             System.out.println("RunnableThread-->" +i);
   15 
   16             // 线程休眠，休眠结束后进入就绪状态，开始抢占Cpu
   17 
   18             if(i == 50)
   19 
   20             {
   21                 try{
   22                     Thread.sleep(2000);
   23                     System.out.println("Sleeping 2000ms");
   24 
   25                 }
   26                 catch(Exception e){
   27                     System.out.println(e);
   28 
   29                 }
   30             }
   31             //让出线程资源-->CPU资源，但是会立马去抢占CPU
   32             if( i == 70)
   33             {
   34                 Thread.yield();
   35                 System.out.println("yield");
   36             }
   37         }
   38     }
   39 }

    

2. 在主函数中先实例化接口实现类，后将该对象作为参数传入到Thread t = new Thread(对象);构造函数中。

 1 package interThread_v001;
 2 public class Runable_Test_v001
 3 
 4 {
 5 
 6     public static void main(String args[])
 7 
 8     {
 9 
10         // 先实例化Runnable的接口实现类
11 
12         Runable_v001 rv = new Runable_v001();
13 
14         // 直接用Thread实例化对象，并把Runnable的接口实现类对象作为参数传入
15 
16         Thread t = new Thread(rv);
17 
18         // 启动线程
19 
20         t.start();
21 
22         //设置线程为最大等级
23 
24         t.setPriority(Thread.MIN_PRIORITY);
25 
26         //获取当前线程的等级
27 
28         System.out.println("当前线程等级-->" +t.getPriority());
29 
30         //主线程中的执行方法 
31 
32         for(int i=0; i<100; i++)
33 
34         {
35             System.out.println("mainThread-->" +i);
36         }
37     }
38 }

 

 

线程的主要方法

 线程同步

 当有多个线程时，调用同一段线程体，有可能就会出现错误。

 如何控制线程不出现错误，就要使用一个线程同步方法——同步代码块 synchronized(this){} ，使用该方法可以确保两个线程对象调用统一个线程体时，该线程体执行完之后才被第二个线程调用。

 

线程实现类：

 1 package interThread_v001;
 2 
 3 public class Sync_v001 implements Runnable
 4 
 5 {
 6     // 实现线程体
 7 
 8     public void run()
 9 
10     {
11         int i = 100;
12 
13         // 线程代码块
14 
15         while (true)
16 
17         {
18             // 同步代码块
19             synchronized (this)
20             {
21 
22                 // 获取当前线程的名字
23 
24                 System.out.println(Thread.currentThread().getName() + "-->" + i);
25 
26                 // i 自减
27 
28                 i--;
29 
30                 // 让出线程占用资源
31 
32                 Thread.yield();
33 
34                 // 退出while循环
35 
36                 if (i < 0)
37 
38                 {
39                     break;
40                 }
41             }
42         }
43     }
44 }

测试类：

 1 package interThread_v001;
 2 
 3 public class Sync_Testv001
 4 
 5 {
 6 
 7     public static void main(String args[])
 8 
 9     {
10 
11         // 接口实现类实例化对象
12 
13         Sync_v001 sThread1 = new Sync_v001();
14 
15         Sync_v001 sThread2 = new Sync_v001();
16 
17        
18 
19         // 实例化线程
20 
21         Thread t1 = new Thread(sThread1);
22 
23         Thread t2 = new Thread(sThread2);
24 
25         t1.setName("线程1");
26 
27         t2.setName("线程2");
28 
29         //启动线程
30 
31         t1.start();
32 
33         t2.start();
34 
35     }
36 
37 }