Java线程Thread解析

线程的状态

简单的来说,线程可以分为以下几种状态:

  • 新建 (new)
  • 就绪 (runnable)
  • 运行中 (running)
  • 阻塞 (blocking)
  • 消亡 (dead)

Thread类主要方法

  • start() 启动线程

  • run() 一旦获取到cpu使用权,Thread会自动执行run方法

  • sleep() 线程等待时间(阻塞),此时该线程仍然占用cpu,注意sleep期间,线程是不会释放锁的

  • yield() 线程让出cpu使用权,重新进入就绪状态(也就是说,它并不会使当前线程进入阻塞状态),等待再次获取使用权,期间的间隔是不固定的,由系统分配。和sleep方法一样不会释放锁

  • join() 被join的线程进入等待状态(阻塞),等join()的线程执行完毕或者指定的时间以后,被join的线程才继续执行
    jion()方法实际上最终调用了Object的wait()方法,让线程进入阻塞状态,释放锁,交出cpu使用权

  • interrupt() 该方法使处于阻塞状态的线程抛出异常从而中断,可以用isInterrupted()和该方法来结束线程

总结一下:可以使线程进入阻塞状态的主要有两个:sleep(),join(),此时调用该线程的interrupt()方法就可以使当前线程抛出异常,我们可以在catch里进行释放操作(线程不会自己结束)

下面看一下代码:


static class A extends Thread{
        @Override
        public void run() {
            for(int i = 0; i<1000; i ++){
                System.out.print("Thread A ---> ");
                System.out.println(i);
                if( i == 100){
                    try {
                        b.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        break;
                    }
                }
            }
        }
    }

    static class B extends Thread{
        @Override
        public void run() {
            for(int i = 0; i<100; i ++){
                System.out.print("Thread B ---> ");
                System.out.println(i);
                try {
                    sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String...args){
        a.start();
        b.start();
        System.out.println("A interrupt");
        a.interrupt();
    }

让A线程打印从1-1000,在打印到100的时候,把b线程join进来,同时在主线程调用a的interrupt()方法。执行结果如下:

A interrupt
Thread A ---> 0
Thread A ---> 1

.....

Thread A ---> 100
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Thread.join(Thread.java:1249)
    at java.lang.Thread.join(Thread.java:1323)
    at com.cris.app.threadTest$A.run(threadTest.java:41)
Thread B ---> 1
Thread B ---> 2
Thread B ---> 3
Thread B ---> 4

可以看到,主线程先执行了a.interrupt();,但是a线程并没有抛出异常,b线程也正常执行,直到 i=100的时候,由于b线程join进来,导致a线程阻塞,此时抛出了InterruptedException,而b线程一直正常执行到结束为止。

注意在catch里的break语句,线程是不会自己结束的,它只是抛出一个异常告诉我们,interrupt被置为了true,我们应该手动去处理它。

可以用interrupt()方法来结束线程,但是最好还是我们自己定义标志位来判断是否需要结束线程。

其他方法:

  • getId()
  • setName()
  • getName()
  • setPriority()
  • getPriority()
  • setDaemon() 设置线程是否成为守护线程和判断线程是否是守护线程
  • isDaemon()
  • currentThread() 静态方法,获取当前线程

守护线程:守护线程依赖于创建它的线程,而用户线程则不依赖,用户线程结束以后守护线程随之结束。比如jvm的垃圾收集器线程,jvm退出以后它自然也没有存在的必要了。

线程协作:wait,notify,notifyAll

这三个方法是Object类中的

  • wait() 当前线程释放锁,进入等待状态
  • notify() 通知其他任意一个等待状态的线程,使其结束等待状态
  • notifyAll() 通知所有等待状态的线程结束等待状态

注意:notify() 和notifyAll只是通知线程结束等待状态,并不能保证哪个线程能获取到锁,如果当前线程没有获取到锁,那它将处于等待锁的状态。


static class ThreadA extends Thread{
        @Override
        public void run() {
            synchronized (o){

                try {
                    System.out.println(Thread.currentThread().getName() + " wait, release lock..");

                    o.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " stop wait, get lock");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " finished, release lock");

            }
        }
    }
    static class ThreadB extends Thread {
        @Override
        public void run() {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + " Start sleep...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " stop sleep... notify, release lock..");
                o.notifyAll();

            }
        }
    }

     static Object o = new Object();
    public static void main(String...args){
         for(int i=0; i<10; i++ ){
            new ThreadA().start();
        }
        new ThreadB().start();
    }

执行结果如下:

Thread-2 wait, release lock..
Thread-3 wait, release lock..
Thread-4 wait, release lock..
Thread-5 wait, release lock..
Thread-6 wait, release lock..
Thread-7 Start sleep...
Thread-7 stop sleep... notify, release lock..
Thread-6 stop wait, get lock
Thread-6 finished, release lock
Thread-5 stop wait, get lock
Thread-5 finished, release lock
Thread-4 stop wait, get lock
Thread-4 finished, release lock
Thread-3 stop wait, get lock
Thread-3 finished, release lock
Thread-2 stop wait, get lock
Thread-2 finished, release lock

首先开启了5个线程A(2-6),全部进入wait状态,但是并不持有锁,然后开启线程B(Thread-7),此时锁被该线程7获取并持有,调用notifyAll以后,所有的A线程被唤醒,但是锁只有一个,被线程6获取,在sleep过程中仍然持有锁,所以等待2秒之后线程6结束,释放锁,下一个线程才能获取到锁继续执行。

你可能感兴趣的:(Java线程Thread解析)