java线程基础知识----线程基础知识

　　不知道从什么时候开始,学习知识变成了一个短期记忆的过程,总是容易忘记自己当初学懂的知识(fuck!),不知道是自己没有经常使用还是当初理解的不够深入.今天准备再对java的线程进行一下系统的学习,希望能够更好的理解使用java线程.

　　1. 什么是线程,线程与进程的差别?(这一块内容我想我已经有了一个理解,这里就不再做记录了)

　　2.java线程的状态:

从百度上随便找了一张图,图中已经很清楚的标注了thread的各个状态以及状态的变化的场景.我们会在接下来的章节中进行相关讲解.

　　3.java实现多线程的方式:

A: 继承Thread类:(在下面的章节进行源码分析)

public class ThreadTest {

    public static void main(String[] args) {

        Thread1 thread1 = new Thread1();

        thread1.start();

    }

}

class Thread1 extends Thread{

    public void run () {

        try {

            Thread.sleep(100L);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

　　　　B: 实现Runnable接口.

public class ThreadTest {

    public static void main(String[] args) {

        Thread thread2 = new Thread(new Thread2());

        thread2.start();

    }

}

class Thread2 implements Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(100L);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

　　4. 实现多线程的两种方法的差别:

　　　　A. 众所周知java不允许多继承,那么我们集成Runnable接口实现多集成就能够很好的避免这个限制.

　　　　B.集成Runnable接口实现多线程有利于程序操作共享资源(后面会提到)

　　　　这个理解起来很简单: 我们继承了Thread类实现run方法之后我们可以发现这样一个问题,我们再进行线程实例化之后我们必须分别启动线程任务.

　　　　　　　　　　　　　　而我们实现Runnable接口的话,我们可以实例化多个Thread类来运行这个任务.

　　　　　　　　　　　　　　当然集成Thread类也并不是不能完成共享资源的分发,而是比较费劲.

　　5. 实例化:我们在初始化Thread类的时候会调用Thread内部的init方法,即便是我们不提供任何参数.init函数的结构: private void init(ThreadGroup g, Runnable target, String name,long stackSize)

　　　参数有:ThreadGroup,Target,name.stackSize,其中ThreadGroup会递归去调用父类的getThreadGroup来进行初始化,等待初始化完成之后我们会通过ThreadGroup调用checkAccess()方法来检查当前线程是否有权限操作此线程.

java源码:

 Thread parent = currentThread();

        SecurityManager security = System.getSecurityManager();

        if (g == null) {

            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager

               what to do. */

            if (security != null) {

                g = security.getThreadGroup();

            }

            /* If the security doesn't have a strong opinion of the matter

               use the parent thread group. */

            if (g == null) {

                g = parent.getThreadGroup();

            }

        }

        /* checkAccess regardless of whether or not threadgroup is

           explicitly passed in. */

        g.checkAccess();

　　其中Thread类的daemon,priority属性会由父类继承.

　　6.Thread类中的方法：

　　　　Thread.sleep(): 此方法调用的是native的方法，本人不才，记得当初看过jdk源码，但是并没看懂底层实现。sleep方法是使当前线程休眠，讲cpu占用权交给其他任意优先级的线程。但是我们应该注意：sleep方法并不会释放对象锁。

　　　　Thread.join(): 记得当初查看api的时候觉得api对join方法的解释非常模糊。到底是谁等待谁结束，这有歧义。其实是这样的，在java7 api中介绍的很清楚，是调用join的线程等待被调用线程执行结束之后再开始执行。这里有一个很值得注意的问题，join的底层调用的是wait方法，而且是循环调用，源码如下：

 long base = System.currentTimeMillis();

        long now = 0;

        if (millis < 0) {

            throw new IllegalArgumentException("timeout value is negative");

        }

        if (millis == 0) {

            while (isAlive()) {

                wait(0);

            }

        } else {

            while (isAlive()) {

                long delay = millis - now;

                if (delay <= 0) {

                    break;

                }

                wait(delay);

                now = System.currentTimeMillis() - base;

            }

        }

　　我们可以看到源码中join方法会在while循环中一直调用wait方法，这是因为如果wait的时间是1000ms，如果在100ms的时候另外一个线程调用了notifyAll方法，那么线程就会苏醒。还要注意第二个问题，就是join调用wait方法，那么我们知道当main线程调用ThreadA.join的时候，main函数会获取ThreadA对象的锁。当ThreadA线程执行完成之后释放该对象锁。下面我们通过一个例子来验证一下上面的论述：我们新建三个线程，B，C，D，然后在B-C-D中进行循环调用。

public class ThreadTest {

    public static ThreadB threadB = new ThreadB();

    public static void main(String[] args) throws InterruptedException{

        System.out.println("main线程开始调用B.join");

        threadB.start();

        threadB.join();

    }

}

class ThreadB  extends Thread{

    public void run(){

        try {

            System.out.println("ThreadB执行ThreadC.join");

            ThreadC threadC = new ThreadC();

            threadC.start();

            threadC.join();

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

class ThreadC extends Thread{

    public void run(){

        try {

            System.out.println("ThreadC执行ThreadD.join");

            ThreadD threadD = new ThreadD();

            threadD.start();

            threadD.join();

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

class ThreadD  extends Thread{

    public void run(){

        try {

            System.out.println("ThreadD执行ThreadB.join");

            ThreadTest.threadB.join();

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

结果：

main线程开始调用B.join

ThreadB执行ThreadC.join

ThreadC执行ThreadD.join

ThreadD执行ThreadB.join

　　可以发现我们的程序一直停留在这个位置，这是因为三个线程满足了死锁的条件，同时也可以证明，thread.join()的调用者必定会获取被调用者的锁。

　　Thread.yield: 此方法与sleep方法类似，但是需要注意一个问题就是Thread.yield只能讲cpu的使用权转交给同等优先级的线程。

　　Thread.start: 最后我们谈一谈Thread.start方法，想必大家都知道Thread.start方法会启动线程，并且执行run方法中的内容。你是否会想我们为什么不直接调用Thread.run来执行呢？其实是这样的，如果我们调用Thread.run来执行的话，jvm并不会真正的启动一个线程，而是将其当做一个普通的方法执行。而调用start的话，在start内部会调用start0方法来新建一个线程。

　　至此：线程的基础知识就结束了，下一章我们会学习关于线程锁的相关知识。

巴特西

java线程基础知识----线程基础知识

最新文章

热门文章