java多线程 基础理解

原文:http://www.cnblogs.com/ckb58/p/7698813.html

1、概述

• 理解多线程先要理解线程，理解线程先要理解进程。

1. 进程

• 一个正在执行的程序。
• 每一个进程的执行都有一个执行的顺序，顺序是一个执行路径，也叫一个控制单元。

2. 线程

• 进程中独立的控制单元称为线程。
• 线程控制进程的执行。
• 进程中只要有一个线程在执行，进程就不会结束。
• 一个进程中至少存在一个线程。

3. 多线程

• Java 虚拟机启动时，会有一个 java.exe 的执行程序，也就是一个进程。
• 这个进程中至少存在一个线程负责 java 程序的执行，这个线程的运行代码存在 main 方法中，这个线程称之为主线程。
• JVM 启动时除了执行一个主线程，还会启动负责垃圾回收机制的线程。
• 在一个进程中有多个线程执行的方式，称为多线程。

4. 多线程的意义

• 多线程能让程序产生同时运行的效果，能够提升程序执行的效率。
  • 例如：
    • java.exe 进程执行主程序时，若是程序的代码很是多，在堆内存中会产生不少对象，而对象调用完后就会变成垃圾。若是垃圾过多的话，可能会致使堆内存出现内存不足的现象，影响程序的运行。这种状况下，若是只有一个线程在运行处理的话，程序执行的效率很是低；若是有多个线程在帮助处理的话，程序执行的效率将大大的提升。
      • 例如：垃圾回收机制的线程在帮助进行垃圾回收的话，那堆内存空间的释放将快不少。

5. CPU 运行的原理

• PC 上有不少程序“同时”进行，看起来好像是 CPU “同时”处理全部程序似的，其实在同一时刻，单核的 CPU 只能运行一个程序，看起来“同时”运行的效果，实际上只是 CPU 在多个线程之间作快速切换的动做而已。
• CPU 执行哪一个程序，或者说是哪一个程序抢到了 CPU 的执行权，哪一个程序就执行，CPU 不会只执行一个线程，执行完一个后，会执行另外一个，或者说是另外一个线程抢走了 CPU 的执行权。至于如何执行是由 CPU 所决定。

• CPU 执行哪一个程序，是毫无规律的，这是多线程的特性：随机性。

  2、建立方式

• 建立线程的方式：继承和实现。

1. 继承

• Java 中已经提供了对线程描述的类 —— Thread。继承 Thread 类，重写（覆盖）run 方法，建立线程。
• 步骤：
  1. 定义类继承 Thread；
  2. 重写（覆盖）Thread 中的 run 方法；
     • 自定义代码存储在 run 方法中，让线程执行。
  3. 建立自定义类的实例对象；
     • 至关于建立线程。
  4. 实例对象调用线程的 start 方法。
     • 启动线程，调用 run 方法。
       • 注：若是对象直接调用 run 方法，那么就只有一个线程在执行，自定义的线程并无启动。
• 重写（覆盖）run 方法的缘由：Thread 类用于描述线程，类中定义了一个功能，用于存储线程要执行的代码，存储这个功能的就是 run 方法。总而言之，Thread 中的 run 方法用于存储线程要执行的代码。

• 例如：

• 结果以下

• 注：线程是随机、交替执行的，每次运行的结果都不一样

 

2. 实现

• 使用继承 Thread 建立线程的方式有弊端，就是若是类继承了其它的父类，就没法使用 Thread 来建立线程，因而便有了经过实现 Runnable 接口来建立线程。实现 Runnable 接口，重写（覆盖）run 方法，建立线程。
• 步骤：
  1. 定义类实现 Runnable；
  2. 重写（覆盖）Runnable 中的 run 方法；
     • 自定义代码存储在 run 方法中，让线程执行。
  3. 经过 Thread 类建立线程对象。
  4. 将 Runnable 的子类对象做为实际参数传递给 Thread 的构造函数；
     • 将 Runnable 的子类对象传递给 Thread 的构造函数的缘由：
       • 自定义的 run 方法所属的对象是 Runnable 的子类对象，要让线程去指定对象的 run 方法，就必须明确 run 方法所属的对象。
  5. 调用 Thread 中的 start 方法启动线程。
     • start 方法会自动调用 Runnable 子类的 run 方法。
• 好处：避免了单继承的局限性。（定义线程时，建议优先使用）
• 例如：

• 结果以下：

• 注：线程是随机、交替执行的，每次运行的结果都不一样。

 

3、区别及状态

1. 建立方式的区别

• 继承：线程代码存储在 Thread 子类的 run 方法中。
• 实现：线程代码存储在 Runnable 子类的 run 方法中。

2. 状态

• 被建立：等待启动，调用 start 启动。
• 运行状态：具备执行资格和执行权。
• 临时状态（阻塞）：具备执行资格，但没有执行权。
• 冻结状态：遇到 sleep(time) 方法和 wait() 方法时，失去执行资格和执行权；sleep 方法的时间结束或调用 notify() 方法时，得到执行资格，变为临时状态（阻塞）。
• 消亡状态：调用 stop() 方法或 run 方法结束。
  • 注：线程从建立状态到了运行状态后，再次调用 start() 方法时，已经没有任何意义，Java 运行时会提示线程状态异常。
  •  

 

4、安全问题

1. 缘由

• 当多条语句操做同一个线程的共享数据时，一个线程对多条语句只执行了一部分，没执行完成时，另外的线程参与执行，会致使共享数据的错误异常，也就是线程的安全问题。
• 总而言之：
  1. 线程的随机性。
  2. 多个线程访问出现延迟。
• 注：线程的安全问题在理想状态下，通常不容易出现，可是一旦出现线程的安全问题，将会对程序软件形成很是大的影响。

2. 同步

• 对于线程的安全问题，在对多条操做共享数据的语句时，只让一个线程执行完，再让下个线程去执行，每条线程在执行的过程当中，其它线程都不能够参与执行。
• Java 中提供了专业的解决办法 —— synchronized（同步）。
• 解决的方式：同步代码块和同步函数。（均是使用关键字 synchronized 实现）
  1. 同步代码块

     • 格式：

       synchronized(对象){ 
           须要被同步的代码;
        }

     • 同步之因此能够解决线程的安全问题，根本缘由在于对象上，对象若是加了同步锁，持有锁的线程能够在同步中执行，没持有锁的线程即便获取 CPU 的执行权，也没法进入去执行，由于没有获取到同步锁。

     • 例如：

同步函数

• 格式：

  在函数上加 synchronized 修饰符便可。

• 函数须要被对象所调用，函数就拥有一个所属对象的引用，就是 this，也就是说同步函数所使用的锁是 this。

• 例如：

• 前提：
  1. 必须有两个或以上的线程；
  2. 必须是多个线程使用同一个锁。
• 利与弊：
  • 利：解决了多线程的安全问题。
  • 弊：多个线程均须要判断锁，消耗资源，影响效率。
• 如何寻找多线程的安全问题？
  1. 明确共享数据；
  2. 明确哪些代码是多线程运行的代码；
  3. 明确多线程运行的代码中哪些语句是操做共享数据的。

3. 静态函数的同步

• 同步函数被静态所修饰后，使用的同步锁再也不是 this，由于静态函数中不能够定义 this，静态进入内存时，内存中没有本类对象，但必定存在类所对应的字节码文件对象。
  • 例如：类名.class（对象的类型是 Class）
• 静态函数所使用的同步锁就是所在类的字节码文件对象。
  • 类名.class

• 例如：

 

4. 死锁

• 同步中嵌套同步时，有可能出现死锁现象。

• 例如：

 

说明：程序卡死，没法继续执行。

5、通讯

• 多个线程操做同一个资源，可是操做的动做不相同，就是线程间通讯。
• 同步操做同一个资源

  • 例如：

 

• 问题点：
  1. wait()、notify()、notifyAll() 用来操做线程的，为何是定义在 Object 类中呢？
     1. 这些方法存在于同步中；
     2. 使用这些方法时必需要有标识所属的同步锁；
        • 例如：同一个锁上 wait 的线程，只能被同一个锁上的 notify 唤醒。
     3. 锁能够是任意的对象，任意对象调用的方法必定要定义在 Object 类中。
  2. wait() 和 sleep() 有什么区别呢？
     • wait()：释放 CPU 的执行权，释放同步锁。
     • sleep()：释放 CPU 的执行权，不释放同步锁。
  3. 为何要定义 notifyAll()？
     • 须要唤醒对方线程时，若是只用 notify()，容易出现只唤醒本方线程的状况，会致使程序中全部线程都处于等待状态。

JDK 5 及以上版本中提供了多线程同步锁的升级解决方案

• 将 synchronized（同步）替换成 Lock，将 Object 类中的 wait()、notify()、notifyAll() 替换成 Condition 对象。
• Condition 对象可经过 Lock（锁）进行获取，而且支持多个相关的 Condition 对象。

• 例如：

•  

 

6、线程中止

• JDK 5 以前，中止线程用 stop() 方法，JDK 5 及以上版本中，stop() 方法已过期。
  • 线程中止的办法就是让 run() 方法结束。
    • 启动多线程运行通常都是使用循环结构的代码，只需控制循环的条件，就可让 run() 方法结束，也就是线程中止。

      • 例如：

 

• 说明：只要在主函数或者其它线程中，对标记 flag 赋值 false，就可让 run() 方法结束，线程中止。

特殊状况：当线程处于冻结状态时，没法读取到 run() 方法中的代码，线程就没法中止。

• 须要对线程的冻结状态进行清除，强制让线程恢复运行，Thread 类中提供了 interrupt();

• 例如：

 

7、什么状况须要多线程？

• 某些代码须要同时执行时，可用单独的线程封装，多线程运行执行。

• 例如

8、拓展

• join();
  • 临时加入线程去执行：
    • 当 A 线程执行到了 B 线程的 join(); 方法时，A 线程等待，B 线程执行完后，A 线程才继续执行（此时的 B 线程与其它线程交替执行）。
• setPriority();
  • 设置优先级：
    • MIN_PRIORITY：最低优先级 1
    • MAX_PRIORITY：最高优先级 10
    • NORM_PRIORITY：默认优先级
• yield();
  • 能够暂停当前线程，让其它线程执行。