1、概述
1.1、程序
概念：程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
1.2、进程
概念：进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程（生命周期）。
- 程序时静态的，进程是动态的。
- 进程作为资源分配的单位，系统在运行时会为每一个进程分配不同的内存区域。
1.3、线程
概念：线程是进程的进一步细化，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多 个线程，就是支持多线程的。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器 ( pc)，线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元和内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来 安全的隐患
【注】：一个 Java 应用程序 java.exe ，其实至少有三个线程 main() 主线程， gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
1.4、并行与并发
- 并行： 多个 CPU 同时执行多个任务。比如：多个人同时做不同的事 。
- 并发： 一 个 CPU（采用时间片）同时执行多个任务，或多个线程使用同一块资源。比如：秒杀。
1.5、使用多线程的优点
背景：以单核 CPU 为例， 只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
多线程程序的优点：
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统 CPU 的利用率。
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
1.6、何时需要多线程
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要 一些后台运行的程序时。
2、线程的创建和使用
2.1、Thread类
1.Thread类特性：
- 每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的，经常把 run() 方法的主体称为 线程体
- 通过该 Thread 对象的 start() 方法 来启动这个线程，而非直接调用 run()
2.构造器
2.2、创建线程
2.2.1、方式1
继承 Thread 类：
- 定义子类继承 Thread 类。
- 子类中重写 Thread 类中的 run() 方法。
- 创建 Thread 子类对象，即创建了线程对象。
- 调用线程对象 start() 方法：启动线程，调用 run() 方法 。
【注】：
- 如果 自己手动调用 run() 方法，那么就只是普通方法，没有启动多线程模式。
- run 方法由 JVM 调用，什么时候调用，执行的过程控制都有操作系统的 CPU调度决定
- 想要启动多线程，必须调用 start 方法 。
- 一 个线程对象只能调用一次 start() 方法启动，如果重复调用了，则将抛出以上的异常“ IllegalThreadStateException 。
2.2.2、方式2
实现 Runnable 接口：
- 定义子类 ，实现 Runnable 接口。
- 子类中重写 Runnable 接口中的 run 方法。
- 通过 Thread 类含参构造器创建线程对象。
- 将 Runnable 接口的子类对象作为实际参数 传递 给 Thread 类 的构造器中。
- 调用 Thread 类的 start 方法：开启线程 调用 Runnable 子类接口的 run 方法。
2.2.3、继承方式和实现方式的联系与区别
区别：
- 继承 Thread ：线程代码存放在 Thread 子类 run 方法中
- 实现 Runnable ：线程代码存放在接口的子类的 run 方法中。
实现方式的好处：
- 避免 了单继承的局限性
- 多个线程可以共享同一个 接口实现类 的对象，非常适合多个相同线程来处理同一份资源。
2.3、Thread类有关方法
2.4、线程的优先级
Java 的调度方法：同优先级线程组成先进先出队列（先到先服务），使用时间片策略；对高优先级，使用优先调度的抢占式策略。
线程的优先级等级：
- MAX_PRIORITY 10
- MIN PRIORITY 1
- NORM_PRIORITY 5
涉及的方法：
- getPriority () ：返回 线程优先值
- setPriority（int newPriority）：改变 线程的优先级
说明：
- 线程 创建时继承父线程 的 优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
- 父线程：父线程的概念是我在翻阅Java-jdk1.8代码的时候看到的，父线程概念第一次是在Thread类的 Init() 方法中提到的，其中g是ThreadGroup类定义的对象。Thread规定，如果Thread构造器在调用的时候没有输入线程组，那么就默认父线程的组为当前线程的组。
- 父线程是“创造子线程的线程”，也就是子线程构造方法所被调用的线程，也即当前线程：Thread parent = currentThread();因为此时子线程在创建中，且未启动，父线程就是当前线程。
- 父线程的提出是沿用于继承中的父子关系中，“创建子类对象，首先要执行父类静态代码块，构造代码块再进行子类的构造”这种先后顺序关系。父线程强调的是，父线程的创建先于子线程，父线程中创造并初始化子线程，没有父线程就没有子线程。但是父线程的结束对子线程没有影响。
2.5、线程的分类
Java中的线程分为两类：一种是 守护线程 ，一种是 用户线程。它们在几乎每个方面都是相同的，唯一的区别是判断 JVM 何时离开。
- 守护线程是用来服务用户线程的，通过在 start() 方法前调用 thread.setDaemon (true) 可以把一个用户线程变成一个守护线程。
- Java 垃圾回收就是一个典型的守护线程。
- 若 JVM 中都是守护线程，当前 JVM 将 退出 。
- 形象理解： 兔死狗烹，鸟尽弓藏
3、线程的生命周期
JDK 中用 Thread State 类定义了 线程的几种状态：
要想实现 多线程 必须在主线程中创建新的线程对象 。 Java 语言使用 Thread 类及其子类的对象来表示线程 在它的一个完整的生命周期中通常要经历如下的五种状态：
- 新建： 当 一个 Thread 类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪： 处于新建状态的线程被 start() 后，将进入线程队列等待 CPU 时间片，此时它已具备了运行 的 条件 ，只是没分配到 CPU 资源
- 运行： 当就绪的线程被调度 并 获得 CPU 资源 时 便进入运行状态， run() 方法定义了线程的操作和功能
- 阻塞： 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡： 线程完成了它的全部工作或线程被提前强制性 地 中止 或出现异常导致结束
4、线程的同步
4.1、问题提出：
- 多个线程执行的不确定性引起执行结果的不稳定
- 多 个线程对 账本 的共享，会造成操作的不完整性，会破坏数据。
例题：模拟火车站售票程序，开启三个窗口售票。
class Ticket implements Runnable {
private int tick = 100;
public void run() {
while (true){
if(tick > 0){
System.out .println(Thread.currentThread().getName() + "售出车票， tick 号为：" + tick--)
}else{
break
}
}
}
}
class TicketDemo {
public static void main(String[] args){
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.setName("t1 窗口");
t2.setName("t2 窗口");
t3.setName("t3 窗口");
t1.start();
t2.start();
t3.start();
}
}
结果：
说明：多线程出现了安全问题
- 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误 。
- 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行 。Java 对于多线程的安全问题提供了专业的解决方式： 同步机制
4.2、Synchronized
- 同步代码块：
synchronized(对象){
//需要被同步的代码块
}
- synchronized 还可以放在方法声明中，表示整个方法为同步方法 。
public synchronized void show (String name){
//需要被同步的代码
}
4.2.1、同步机制中的锁
同步机制：
在《 Thinking in Java 》 中 是这么说的：对于并发工作 你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争） 。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁 。 第一个访问某项资源的任务必须锁定这项资源， 使其他任务在其被解锁之前，就无法访问它了。 而在其被解锁之时， 另一个任务就可以锁定并使用它了 。
synchronized 的锁是什么？
- 任意对象都可以作为同步锁 。 要求多个线程必须共用同一把锁（监视器）。
- 同步方法的锁：静态方法 类名( class ) 、 非静态方法( this )
- 同步代码块：自己指定 很多时候也是指定为 this 或类名 class
【注意】：
- 必须确保使用同一个资源的 多个线程共用一把锁， 这个非常重要， 否则就无法保证共享资源的安全。
- 一个线程类中的所有静态方法共用同一把锁 ( 类名 class )， 所有非静态方法共用同一把锁 ( this )， 同步代码块（ 指定需谨慎）。
4.2.2、同步的范围
1、如何找问题，即代码是否存在线程安全？
- 明确哪些代码是多线程运行的代码
- 明确多个线程是否有共享数据
- 明确多线程运行代码中是否有多条语句操作共享数据
2、如何解决？
对多条操作共享数据的语句，只能让一个线程都执行完， 在执行过程中， 其他线程不可以参与执行 。
即所有操作共享数据的这些语句都要放在同步范围中。
3、切记
- 范围太小：没锁住所有有安全问题的代码
- 范围太大：没发挥多线程的 功能 。
4.2.3、释放锁与不会释放锁的操作
释放锁：
- 当前 线程的同步方法、同步代码块 执行结束。
- 当前 线程在同步代码块或同步方法中遇到 break 、 return 终止了该代码块或该方法的继续执行。
- 当前 线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception 导致异常结束。
- 当前 线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁。
不会释放锁：
- 线程执行同步代码块或同步方法时，程序调用 Thread.sleep() 、Thread.yield() 方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起，该线程不会释放锁（同步监视器）。(应尽量避免使用 suspend() 和 resume() 来控制线程)
4.2.4、线程的死锁
死锁：
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程 的 死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决：
- 专门的算法、原则
- 尽量减少同步资源 的 定义
- 尽量避免嵌套同步
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread() {
public void run() {
synchronized(s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread() {
public void run() {
synchronized(s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
}
4.3、 Lock锁
- 从 JDK 5.0 开始 Java 提供了更强大的线程同步机制， 通过显式定义同步锁对象来实现同步，同步锁使用 Lock 对象充当。
- java.util.concurrent.locks.Lock 接口是 控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象 。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义， 在 实现线程安全的控制中，比较常用的是 ReentrantLock 可以显式加锁、释放锁 。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码
}
finally{
lock.unlock();
}
}
}
【注意】：如果同步代码有异常，要将unlock() 写入 finally 语句块
4.4、synchronized 与 Lock 的对比
- Lock 是显式锁（手动开启和关闭锁，别忘记关闭锁）， synchronized 是隐式锁，出了作用域自动释放
- Lock 只有代码块锁， synchronized 有代码块锁和方法锁
- 使用 Lock 锁， JVM 将花费较少的时间来调度线程，性能更好。并且具有 更好的扩展性（提供更多的子类），推荐使用！
5、线程的通信
例：使用两个线程打印 1 100 。线程 1, 线程 2 交替打印
class Number implements Runnable{
private int num = 1;
@Override
public void run() {
while (true){
synchronized (this) {
notify();
if (num <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + num);
num++;
try {
wait(); //wait()方法会释放锁，sleep()方法不会
} catch (InterruptedException e) {
}
} else {
break;
}
}
}
}
}
public class ThreadCommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
5.1、wait () 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃 CPU 和 同步资源并等待， 使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用 notify() 或 notifyAll() 方法唤醒（阻塞），唤醒后（就绪）等待重新获得对监视器的所有权后才能继续执行。
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待（从阻塞到就绪）
- notifyAll()：唤醒正在排队等待资源的所有线程结束等待（从阻塞到就绪）
【注】：
- 这 三个方法只有在 synchronized 方法或 synchronized 代码块中才能使用，否则会报java.lang.IllegalMonitorStateException 异常。
- 因为 这三个方法必须有锁对象调用，而任意对象都可以作为 synchronized 的同步锁，因此这三个方法只能在 Object 类中声明 。
- 这三个方法调用的必要条件：当前线程必须具有对该对象的监控权（加锁）
经典例题：生产者/消费者问题
生产者 ( Productor ) 将产品交给店员 ( Clerk)，而消费者 ( 从店员处取走产品，店员一次只能持有固定数量的产品 比如 :20 ），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：
- 生产者比消费者快时，消费者会漏掉一些数据没有取到。
- 消费者比生产者快时，消费者会取相同的数据。
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
p1.start();
c1.start();
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始生产产品。。。");
while(true){
try {
Thread.sleep(19);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produce();
}
}
}
class Consumer extends Thread{
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始消费产品。。。");
while(true){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.comsume();
}
}
}
class Clerk{
private int num = 0;
public synchronized void produce() {
if (num >= 20){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + num + "个产品");
notify();
}
public synchronized void comsume() {
if (num <= 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + ":开始消费第" + num + "个产品");
num--;
notify();
}
}
扫一扫
369
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
