【Java学习笔记】【Day7】线程

---

申明：

        内容来源于老师的课堂笔记，这只是我的整理以及一些额外补充。

---

十一、线程

了解点

1. 线程的概念

   1. 线程并发：多个线程同时运行，其实线程并发只是一种表象，实际上是因为cpu的运算速度快而让使用者感觉不到等待。Cpu接到线程执行指令时是抢占式调度执行的

   2. 对于Java应用程序而言，有三个基础线程：main线程(主线程)、GC线程、异常线程

   3. 
2. 线程优先级
   1. 

   2.  

3. JUC
   1. 概念
      1. 
   2. 实现
      1. 创建两个等待线程
         1. 
      2. 创建一个或多个唤醒线程
         1. 
      3. 测试
         1.  
   3. 作用
      1. 

掌握点

1. 线程的开发
   1. 继承Thread类，重写run()
      1. run()是由JVM调度执行的，线程中不能手动调用（手动调用无线程效果）
      2. eg: 

         public class Thread1 extends Thread{
         	public void run() {
         		System.out.println("----------Thread1-run()------------");
         	}
         }
         
         public static void main(String[] args) {
         	Thread t1 = new Thread1();
         	t1.start();
         }

   2. 实现Runnable接口，重写run()
      1. eg: 

         public class Thread2 implements Runnable{
         	public void run() {
         		System.out.println("----------Thread2-run()------------");
         	}
         }
         
         
         public class Test {
         	
         	    public static void main(String[] args) {
         	    	Runnable tt2 = new Thread2();
         	    	Thread t2 = new Thread(tt2);
         	    	t2.start();
         	    }
         }

   3. 两种创建方式的比较
      1. 
2. 线程的方法
   1. 基础方法

      1. public class Thread1 extends Thread{
         	public void run() {
         		this.setName("1");
         		this.getName();
         		this.isAlive();
         		System.out.println("----------Thread1-run()------------");
         	}
         }

   2. 线程的基本状态
      1. Thread类中有一个枚举类State，记录了线程的生命周期各种状态
      2. 
      3. 
   3. 线程的阻塞-sleep()
      1. 运行中的线程由于外部资源的缺失或者调用了sleep方法，则会进入阻塞状态
      2. 
      3. 
      4.  sleep()方法让当前线程进入睡眠/阻塞状态，等待指定时间后，线程自动醒来恢复到可运行状态。
      5. 一个对象调用sleep()后，不会释放当前对象的状态（对象所持有的对象锁），所以不会影响其他线程的运行。
      6. sleep()指定的睡眠时间无法精确的控制线程的运行流程
      7. 
   4. Join()
      1. join()方法同样可以导致当前线程进入阻塞状态
      2. 执行特点：当前线程中如果调用了另外一个线程的join方法，当前线程会立即阻塞，直到另一个线程完全执行完成。
      3. 
   5. yield()
      1. yield()方法不会进入到阻塞状态，当线程调用此方法后，当前线程释放掉系统资源，由系统再次调用执行，此时，当前线程继续抢占资源，有可能继续抢占到资源。
3. 线程练习
   1. 
   2. 实现方法：
      1. 栈的大小固定，先使用普通方式实现栈
      2. 在①中把pop和push通过两个线程实现
      3. 两个线程操作的是同一个数组
      4. 运行下栈的操作，看发现什么问题？ 
4. 线程安全
   1. 线程不安全：多个线程并发访问了同一个临界资源对象，若破坏了对象的原子操作，从而有可能造成数据不一致。
   2. 要解决线程安全问题，就要保障原子操作不被破坏
      1. 解决线程安全问题的方法：
         1. 用synchronized修饰语句块（原子操作）
         2. 用synchronized修饰方法
         3. 注意
            1. synchronized关键字可以修饰run()方法同样能够实现线程同步
         4. 面试题：

            1. 多线程操作同类不同对象中的静态方法[Synchronized修饰]时，会不会同样能够实现线程同步？按正常理解多个线程实现对同一个对象的操作，此时验证多线程对多个对象操作，看static方法能否可以线程同步？

            2. 

            3. 

      2. Lock锁定线程
         1. 可以通过Lock接口对象去锁定原子操作，以达到线程同步的目的

         2. 通过try...finally方法确保锁一定被释放

         3. 面试题

         4. 练习

5. 线程通信
   1. 死锁
      1. 当两个线程彼此占用对方所需要的对象锁，且彼此都不释放对象锁资源时，即两个线程进入死锁状态。
      2. 可以通过Object中的wait()和notify()方法来实现线程之间的通信【这两个方法一定是在synchronized语句中执行的】
      3.  
   2. 线程通信实现
      1. 生产者与消费者问题
         1. 两个线程操作同一个对象：一个线程只负责不断地生产资源，另一个线程只负责不断地消费资源
         2. 
         3.  
      2. 
6. Java阻塞队列
   1. 阻塞队列
      1. 队列-Queue-FIFO
      2. 
   2. ArrayBlockingQueue
      1. 类结构图
      2. API值对
      3. 实现
      4. 基本API：
   3. ArrayBlockingQueue源码分析
      1. 基本属性定义
      2. Take()
      3. Put(e)
      4. 总结
7. 单例模式的线程安全问题
   1. 详情参考：Java 单例模式及线程安全问题_LittleSkey的博客-CSDN博客
8. Callable接口创建线程
   1. Callable说明
      1. Callable是Java5中新增的创建线程的方法
      2. 
      3. Callable是一个普通的接口，需要借助FutureTask类来实现线程的功能，FutureTask是实现了Runnable接口的，所以线程真正执行的还是run()，也需要借助Thread类中的start()启动线程。
   2. Callable使用
      1.   
9. 线程池
   1. 概念
      1. 
      2.  线程池涉及的接口和类：
   2. 实现
      1. 创建一个Thread1、2两个线程，交给ExecutorService进行管理
   3. 管理线程池
      1.  
10. 线程类型
    1.  
11. 线程面试题
    1. 如何让所有线程都执行完后再打印一条日志记录（即让主线程最后执行完）

---