java多线程详解

java多线程详解

实现方式

有三种，一种extends两种implements

package lennie;import java.util.concurrent.Callable;import java.util.concurrent.FutureTask;public class Test {public static void main(String[] args) {    MyThread my = new MyThread();    my.start();    MyRunnable mr = new MyRunnable();    new Thread(mr).start();    MyCallable mc = new MyCallable();    FutureTask<String> fTask = new FutureTask<String>(mc);    Thread thread = new Thread(fTask);    thread.start();    try{        String s = fTask.get();        System.out.println(Thread.currentThread().getName() + " s = " + s);    }catch (Exception e) {        // TODO: handle exception    }}static class MyThread extends Thread {    private MyThread() {    }    private MyThread(Runnable r) {        super(r);    }    @Override    public void run() {        // TODO Auto-generated method stub        for (int i = 0; i < 10; i++) {            System.out.println("MyThread = " + Thread.currentThread().getName() + "  i = " + i);        }    }}static class MyRunnable implements Runnable {    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println("MyRunnable = " + Thread.currentThread().getName() + "   i = " + i);        }    }}static class MyCallable  implements Callable<String>{    private MyCallable(){        System.out.println(Thread.currentThread().getName() + "  MyCallable  ==> " );    }    @Override    public String call() throws Exception {        // TODO Auto-generated method stub        System.out.println(Thread.currentThread().getName() + "   call() ==> ");        return "123456";    }}}

生周期

• 初始状态（New）：当线程对象对创建后，即进入了初始状态，如：Thread t = new MyThread();

• 可运行状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入可运行状态。处于可运行状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

• 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：可运行状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于可运行状态中；

• 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

  1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

• 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

常用函数说明

• sleep()

  使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。

• wait()

  是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。wiat()必须放在synchronized block中，否则会在program runtime时扔出 ”java.lang.IllegalMonitorStateException“异常。

  注：Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用

• join()

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

• yield()

作用是：暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。* yield()从未导致线程转到等待、睡眠、阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。*

• setPriority()

更改线程的优先级

    MIN_PRIORITY = 1    NORM_PRIORITY = 5    MAX_PRIORITY = 10

• interrupt()

中断某个线程，这种结束方式比较粗暴，如果A线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭要想结束进程最好的办法就是用sleep()函数，在线程类里面用以个boolean型变量来控制run()方法什么时候结束，run()方法一结束，该线程也就结束了。

• notify(): 通知一个线程继续运行。

• activeCount(): 程序中活跃的线程数。

• enumerate(): 枚举程序中的线程。

• currentThread(): 得到当前线程。

• isDaemon(): 一个线程是否为守护线程。

• setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)

• setName(): 为线程设置一个名称。

三种线程的区别

• Thread和Runnable的区别

  1.适合多个相同的程序代码的线程去处理同一个资源2.可以避免java中的单继承的限制3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

• Callable与Thread、Runnable的区别

  1、Callable具有返回值，而Thread、Runnable则没有2、实现方式也不一样

wait和sleep区别

共同点：

1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。

2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
   如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
   需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点：

1. Thread类的方法：sleep(),yield()等
   Object的方法：wait()和notify()等

2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常所以sleep()和wait()方法的最大区别是：

   　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
   　　　　而wait()睡眠时，释放对象锁。

但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

sleep()和yield()的区别

一个是立马进入停滞状态，一个时候在指定的时间内进入停滞状态。

sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程

另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

线程调度

1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。

    每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。    线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。    JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。

2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。

3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

4、线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

6、线程唤醒

线程同步

1、synchronized关键字： 可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

    A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。    B．每个对象只有一个锁（lock）与之相关联。    C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

2、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。

3、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。

4、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

5、对于同步，要时刻清醒在哪个对象上同步，这是关键。

6、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

7、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

8、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

线程数据传递

• 构造传参

              public A(String value){                        this.value = value;                }

• 方法和变量传参

              public boolean isRun = false;            public void setVslue(String value ){                    this.value = value;            }            public void setData(Data data ){                    this.data = data;            }