多线程爬坑之路-Thread和Runable源码解析之基本方法的运用实例


前面的文章:多线程爬坑之路-学习多线程需要来了解哪些东西?(concurrent并发包的数据结构和线程池,Locks锁,Atomic原子类)

      多线程爬坑之路-Thread和Runable源码解析 

 

 

前面大致的了解了Thread的一些方法和属性下面对一些方法进行运用看看具体效果<下面可能还是会贴很多的源代码,其实我是拒绝的,我只想贴每个方法的代码,但是有时候看到一个方法里面有调用了方法,但是笔者有没有给出来,很蛋疼,有种爽到一半的感觉,所以我还是会把它贴出来,希望一次就能挖到底,不论有没有全懂,但至少懂了几分。>

activeCount():返回当前线程所属线程组的活动线程数

源代码如下:  

 1  /**
 2      * Returns an estimate of the number of active threads in the current
 3      * thread's {@linkplain java.lang.ThreadGroup thread group} and its
 4      * subgroups. Recursively iterates over all subgroups in the current
 5      * thread's thread group.
 6      *
 7      * <p> The value returned is only an estimate because the number of
 8      * threads may change dynamically while this method traverses internal
 9      * data structures, and might be affected by the presence of certain
10      * system threads. This method is intended primarily for debugging
11      * and monitoring purposes.
12      *
13      * @return  an estimate of the number of active threads in the current
14      *          thread's thread group and in any other thread group that
15      *          has the current thread's thread group as an ancestor
16      */
17     public static int activeCount() {
18         return currentThread().getThreadGroup().activeCount();
19     }

这个静态方法先调用了一个currentThread()方法获取当前线程,然后调用了getThreadgroup()获取线程组,最后调用了activeCount()方法获取活动线程数。下面是调用的方法的具体实现,native方法调用的是VM的实现,需要下载VM的源码才能查看,这里先略过。

/**
     * Returns a reference to the currently executing thread object.
     *
     * @return  the currently executing thread.
     */
    public static native Thread currentThread();

/**
     * Returns the thread group to which this thread belongs.
     * This method returns null if this thread has died
     * (been stopped).
     *
     * @return  this thread's thread group.
     */
    public final ThreadGroup getThreadGroup() {
        return group;
    }

/**
     * Returns an estimate of the number of active threads in this thread
     * group and its subgroups. Recursively iterates over all subgroups in
     * this thread group.
     *
     * <p> The value returned is only an estimate because the number of
     * threads may change dynamically while this method traverses internal
     * data structures, and might be affected by the presence of certain
     * system threads. This method is intended primarily for debugging
     * and monitoring purposes.
     *
     * @return  an estimate of the number of active threads in this thread
     *          group and in any other thread group that has this thread
     *          group as an ancestor
     *
     * @since   JDK1.0
     */
    public int activeCount() {
        int result;
        // Snapshot sub-group data so we don't hold this lock
        // while our children are computing.
        int ngroupsSnapshot;
        ThreadGroup[] groupsSnapshot;
        synchronized (this) {
            if (destroyed) {
                return 0;
            }
            result = nthreads;
            ngroupsSnapshot = ngroups;
            if (groups != null) {
                groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
            } else {
                groupsSnapshot = null;
            }
        }
        for (int i = 0 ; i < ngroupsSnapshot ; i++) {
            result += groupsSnapshot[i].activeCount();
        }
        return result;
    }

方法的使用:

 1 /**
 2  * thread method test
 3  * @author Ljcx
 4  *
 5  */
 6 public class ThreadMethord implements Runnable{
 7     @Override
 8     public void run() {
 9         System.out.println("");
10         try {
11             Thread.sleep(1000);
12         } catch (InterruptedException e) {
13             e.printStackTrace();
14         }
15     }
16     
17     public static void main(String[] args) {
18         ThreadMethord    tm = new ThreadMethord();
19         Thread th = new Thread(tm);
20         th.start();
21         System.out.println("--活动线程数--"+th.activeCount());
22         ThreadMethord    tm2 = new ThreadMethord();
23         Thread th2 = new Thread(tm2);
24         th2.start();
25         System.out.println("--活动线程数--"+th2.activeCount());
26     }
27 }

运行结果:

--活动线程数--2
--活动线程数--3

程序启动一共创建了三个线程:main,th,th2,主线程启动main函数,线程th启动,此时的活动线程为main,th.然后创建线程th2并启动。此时活动线程数是main,th,th2.把上面的代码稍微修改一下

 1 public class ThreadMethord implements Runnable{
 2     public void run() {
 3         System.out.println("");
 4         /*try {
 5             Thread.sleep(1000);
 6         } catch (InterruptedException e) {
 7             e.printStackTrace();
 8         }*/
 9     }
10 
11     public static void main(String[] args) {
12         ThreadMethord    tm = new ThreadMethord();
13         Thread th = new Thread(tm);
14         th.start();
15         System.out.println("--活动线程数--"+th.activeCount());
16         ThreadMethord    tm2 = new ThreadMethord();
17         Thread th2 = new Thread(tm2);
18         th2.start();
19         System.out.println("--活动线程数--"+th2.activeCount());
20     }
21 }

运行结果:

1 --活动线程数--2
2 --活动线程数--2

好像跟预期的结果不一样,只是因为把线程休眠去掉了,那是因为在th2启动的时候th1已经运行结束了。

基本属性的获取方法:

方法使用:

 1 public class ThreadMethord implements Runnable{
 2     public void run() {
 3         System.out.println("");
 4         System.out.println("-当前线程的引用--"+ Thread.currentThread());
 5         try {
 6             Thread.sleep(1000);
 7         } catch (InterruptedException e) {
 8             e.printStackTrace();
 9         }
10     }
11 
12     public static void main(String[] args) {
13         ThreadMethord    tm = new ThreadMethord();
14         Thread th = new Thread(tm);
15         th.start();
16         System.out.println("--活动线程数--"+th.activeCount());
17         ThreadMethord    tm2 = new ThreadMethord();
18         Thread th2 = new Thread(tm2);
19         th2.start();
20         System.out.println("--活动线程数--"+th2.activeCount());
21         Thread  [] tarray = new Thread[3]; 
22         System.out.println("-当前线程的引用--"+ Thread.currentThread());
23         Thread.enumerate(tarray);//将当前线程的所有活动线程放进数组里
24         for (Thread thread : tarray) {
25             System.out.println("--tarray活动线程--"+thread);
26         }
27         
28         System.out.println("--th线程ID--"+th.getId());
29         System.out.println("--th的线程名--"+ th.getName());
30         System.out.println("--th的线程优先级--"+ th.getPriority());
31         System.out.println("--th的线程组--"+ th.getThreadGroup());
32         
33         
34         System.out.println("--th2线程ID--"+th2.getId());
35         System.out.println("--th2的线程名--"+ th2.getName());
36         th2.setPriority(6);//设置优先级
37         System.out.println("--th2的线程优先级--"+ th2.getPriority());
38         System.out.println("--th2的线程组--"+ th2.getThreadGroup());
39     }
40 }

运行结果:

 1 --活动线程数--2
 2 --活动线程数--3
 3 -当前线程的引用--Thread[main,5,main]
 4 
 5 --tarray活动线程--Thread[main,5,main]
 6 --tarray活动线程--Thread[Thread-0,5,main]
 7 --tarray活动线程--Thread[Thread-1,5,main]
 8 
 9 --th线程ID--10
10 --th的线程名--Thread-0
11 --th的线程优先级--5
12 --th的线程组--java.lang.ThreadGroup[name=main,maxpri=10]
13 --th2线程ID--11
14 --th2的线程名--Thread-1
15 --th2的线程优先级--6
16 --th2的线程组--java.lang.ThreadGroup[name=main,maxpri=10]
17 
18 -当前线程的引用--Thread[Thread-0,5,main]
19 -当前线程的引用--Thread[Thread-1,6,main]

可以看到主线程他的引用就是main,优先级是5,所属线程组是main,th和th2他们的引用分别是Thread-0,Thread-1,这是他们的线程名,因为我们在创建现成的时候没有个他初始化名称,所以默认使用Thread-加上线程组内线程创建的序号。(说多了我以为我在胡扯,来看一波源代码)

源代码:

//这个初始化方法是我们调用的,可以看到他的命名方式:“Thread-“+nextThreadNum(),这个nextThreadNum方法是一个同步的方法,加了
//sychnorized锁,返回的是一个私有的静态的int类型的属性,所以他的默认值应该是0,说到这有的小伙伴可能有疑问了,既然默认值(初始值)0,
//那么这里返回的是threadInitNumber++,那第一个线程名应该是Thread-1,问题又回到了++i和i++的问题了,不多说了。
public
Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); } /*初始化方法的四个参数第一个线程组,第二个线程,第三个线程名,第四个是栈大小

 private void init(ThreadGroup g, Runnable target, String name,long stackSize) {

    init(g, target, name, stackSize, null);
  }*/

private static int threadInitNumber;
private static synchronized int nextThreadNum() {
     return threadInitNumber++;
}

getState():获取线程状态

方法使用:

 1 public class TestMethord2 implements Runnable{
 2     @Override
 3     public void run() {
 4         //获取当前线程的引用
 5         Thread obj = Thread.currentThread();
 6         System.out.println("线程:"+obj.getName()+"的状态:"+obj.getState());//RUNNABLE
 7         try {
 8             Thread.sleep(2000);
 9         } catch (InterruptedException e) {
10             e.printStackTrace();
11         }
12     }
13     public static void main(String[] args) {
14         TestMethord2 t1 = new TestMethord2();
15         TestMethord2 t2 = new TestMethord2();
16         Thread th1 = new Thread(t1,"th1");
17         System.out.println(th1.getState());//NEW
18         th1.start();
19         System.out.println(th1.getState());//RUNNABLE
20         //等待线程执行到sleep
21         try {
22             Thread.sleep(1000);
23         } catch (InterruptedException e) {
24             e.printStackTrace();
25         }
26         System.out.println(th1.getState());//TIMES_WAITING
27         //等待线程th1执行完毕
28         try {
29             Thread.sleep(1000);
30         } catch (InterruptedException e) {
31             e.printStackTrace();
32         }
33         System.out.println(th1.getState());//TERMINATED
34     }
35 }

运行结果:(跑一下代码一目了然可以看到不同的状态)

1 线程th1的状态:NEW
2 线程th1的状态:RUNNABLE
3 RUN线程th1的状态:RUNNABLE
4 线程th1的状态:TIMED_WAITING
5 线程th1的状态:TERMINATED

开始创建的时候状态是:NEW。start之后线程执行,状态是RUNNABLE,此时主线程进入休眠1秒,是为了等待th1进入到休眠状态,当th1进入休眠状态2秒,主线程已经结束了休眠此时在查看th1的状态为TIMED_WAIING,我们再让主线程等待1秒,th1结束了休眠,执行完毕,再次查看th1状态为TERMINATED。

跟状态相关的方法:

yield:暂停当前线程,让其他线程先执行。

 1 public class TestMethord3 implements Runnable{
 2 
 3     @Override
 4     public void run() {
 5         System.out.println(Thread.currentThread().getName()+"runing.....");
 6         
 7         for (int i = 0; i <10; i++) {
 8             System.out.println(Thread.currentThread().getName()+":"+i);
 9             if(i==3){
10                 Thread.yield();
11             }
12         }
13     }
14     public static void main(String[] args) {
15         TestMethord3 tm1 = new TestMethord3();
16         TestMethord3_2 tm2 = new TestMethord3_2();
17         Thread th1 = new Thread(tm1, "th1");
18         Thread th2 = new Thread(tm2, "th2");
19         th1.start();
20         th2.start();
21     }
22 }
1 public class TestMethord3_2 implements Runnable{
2     public void run() {
3         System.out.println(Thread.currentThread().getName()+"runing.....");
4         for (int i = 0; i < 10; i++) {
5             System.out.println("------------------"+i);
6         }
7     }
8 }

运行结果:这个结果每次运行都不一样。

 1 th2runing.....
 2 th1runing.....
 3 ------------------0
 4 ------------------1
 5 ------------------2
 6 ------------------3
 7 ------------------4
 8 ------------------5
 9 ------------------6
10 th1:0
11 ------------------7
12 th1:1
13 ------------------8
14 ------------------9
15 th1:2
16 th1:3
17 th1:4
18 th1:5
19 th1:6
20 th1:7
21 th1:8
22 th1:9

按照理想上来说,我们在th1运行到输出3的时候就应该停下来让th2先执行完,th1和th2是我交叉执行应该只发生在th1输出3之前。然而结果并不是如此,多运行几次就会发现,这个yield方法并没有起到应有的作用,这是由于CPU资源充足的情况下两个都能获取到CPU,暂停当前线程的执行可能只是在CPU资源不足的情况下让出CPU资源。(个人理解),但是就算是CPU资源不充足,两个同等优先级的线程在一个暂停之后仍然有同等几率被调度选中分配到资源,所以说这个yield方法同等优先级的情况下出现不管用的几率会更大。

join:等待某线程终止

 1 public class TestMethord3 implements Runnable{
 2     public void run() {
 3         System.out.println(Thread.currentThread().getName()+"runing.....");
 4         
 5         for (int i = 0; i <10; i++) {
 6             System.out.println(Thread.currentThread().getName()+":"+i);
 7             if(i==3){
 8                 Thread.yield();
 9             }
10         }
11     }
12     public static void main(String[] args) throws InterruptedException {
13         TestMethord3 tm1 = new TestMethord3();
14         TestMethord3_2 tm2 = new TestMethord3_2();
15         Thread th1 = new Thread(tm1, "th1");
16         Thread th2 = new Thread(tm2, "th2");
17         th1.start();
18         th2.start();
19         th2.join();
20         System.out.println("th2的状态:"+th2.getState());
21     }
22 }
23 
24 public class TestMethord3_2 implements Runnable{
25     public void run() {
26         System.out.println(Thread.currentThread().getName()+"runing.....");
27         for (int i = 0; i < 10; i++) {
28             System.out.println("------------------"+i);
29         }
30     }
31 }

运行结果:下面是运行四次的结果显示,从结果中可以看出,无论th1,th2怎么运行,最终主线程输出的th2的状态都是TERMINATED,因为这一行输出是放在th2.join()后面的,表示的是主线程要等待th2执行完毕才能继续执行。

wait(),wait(long million),notify(),notifyAll(),这几个方法继承自Object类.

wait()和wait(long million):指的是让线程等待,与sleep的不同的是,wait方法会释放CPU,而sleep仍然占有CPU资源。

notify():指的是唤醒某个线程

notifyAll() :指的是唤醒所有的线程

这几个方法需要组合使用,在多个线程运行时涉及到的先后问题,暂时还未研究深入,先放一下。后面会补充上。

 

通过上面这些方法,基本上了解了线程这个类。除去基本的属性方法,其他的跟状态相关的在复杂的并发线程环境中才能体现他们的作用和价值,也才能展现出使用上的难度,这里所涉及到的不过是九牛一毛,后面继续探索。