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 }

1. 在主函数中先实例化接口实现类，后将该对象作为参数传入到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 }