java多线程总结

多线程的几种实现方式

  • 继承Thread类 重写run（）方法定义线程的行为；
    如下图所示
    avatar

  • 实现Runnable接口
    如下图所示

  • 实现 Callable 接口，该接口中的 call方法可以在线程执行结束时产生一个返回值。
    使用总结：因为 Java 中的继承是单继承，一个类有一个父类，如果继承了 Thread 类就无法再继承其 他类了，显然使用 Runnable 接口更为灵活。
    实现Runnable接口比继承Thread类所具有的优势：

            1）：适合多个相同的程序代码的线程去处理同一个资源

        2）：可以避免java中的单继承的限制

        3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

        4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类  
创建多线程的三种方式:两个接口（Runnable、Callable）一个类（Thread）

    实例变量与线程安全

    自定义线程类中的实例变量针对其他线程可以有共享与不共享之分。当每个线程都有各自的实例变量时，就是变量不共享。共享数据的情况就是多个线程可以访问同一个变量。
来看下面的示例：
        打印的结果中存在多个线程同时对count进行操作，产生了"非线程安全"问题     

    * 在某些JVM中，i--的操作要分成如下3步：  

    * 取得原有变量的值。计算i-1。对i进行赋值。  

    * 在这三个步骤中，如果有多个线程同时访问，那么一定会出现非线程安全问题。  

    解决方法就是使用 synchronized 同步关键字 使各个线程排队执行run()方法。修改后的run()方法：

synchronized 关键字的用法

       在上面提到"同步"关键字，synchronized关键字可以将方法或者对象标记为同步，以实现对对象和法
    的互斥访问，可以用synchronized(对象) { … }定义同步代码块，或者在声明方法时将 
    synchronized 作为方法的修饰符。   

    如果系统中存在临界资源（资源数量少于竞争资源的线程数量的资源），例如正在写的数据以后可能被另
    一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就必须进行同步存取（数
    据库操作中的排他锁就是最好的例子）。当应用程序在对象上调用了一个需要花费很长时间来执行的方
    法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效
    率。事实上，所谓的同步就是指阻塞式操作，而异步就是非阻塞式操作。

线程的状态变化

    要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行
    阻塞，终止。下面分别介绍一下这几种状态：

  • 创建状态

    在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存
空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现，例如
 “Thread thread=new Thread()”。

  • 就绪状态

    新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此
时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。

  • 运行状态

    当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run()
 方法。run() 方法定义该线程的操作和功能。

  • 阻塞状态

    一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时
中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线
程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以
转入就绪状态。

  • 死亡状态

    线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续
运行的能力。

在此提出一个问题，Java 程序每次运行至少启动几个线程？

回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实
际上就是在操作系统中启动一个线程，Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启
动两个线程，一个是 main 线程，另外一个是垃圾收集线程。

    线程状态之间的转换如下所示

    1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于
  可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，调用run()方法执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就
  绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为
      阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转
      入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

    线程调度

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

    Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
    * static int MAX_PRIORITY
              线程可以具有的最高优先级，取值为10。
    * static int MIN_PRIORITY
              线程可以具有的最低优先级，取值为1。
    * static int NORM_PRIORITY
              分配给线程的默认优先级，取值为5。

    Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。

    每个线程都有默认的优先级。主线程的默认优先级为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、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在
此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用
其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被
唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤
醒在此对象监视器上等待的所有线程。
 注意：Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向

    为什么要用join()方法

    在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子
线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等
待子线程执行完成之后再结束，这个时候就要用到join()方法了。