9 线程

9.1 线程概述
9.2 多线程实现方式
- 方式一继承Thread类
- 方式二相比方式一有啥好处
9.5 设置和获取线程名称
9.6 线程控制
9.7 线程调度

9.1 线程概述

是进程中的单个顺序控制流，是一条执行路径
单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序

9.2 多线程实现方式

方式一继承Thread类
定义一个MyThread的继承Thread类
在MyThread类中重写run()方法
- 重写run()是因为用来封装被线程执行的代码
- run()：封装线程执行的代码，直接调用，相当于普通方法的调用
创建MyThread类的对象
启动线程 —> start()：然后由JVM调用此线程的run()方法 ```java import java.io.*;

public class Demo { public static void main(String[] args) throws IOException { MyThread my1 = new MyThread() ; MyThread my2 = new MyThread() ; //如果直接调用run()方法，就是普通的按顺序执行，不会同时开启线程 // my1.run(); // my2.run(); my1.start(); my2.start(); } }

![图片.png](https://cdn.nlark.com/yuque/0/2021/png/21763574/1623412745549-ad3b228e-284e-4c43-a855-97c1d230973d.png#clientId=udda8f812-f6c4-4&from=paste&height=164&id=u6e2e8eb6&margin=%5Bobject%20Object%5D&name=%E5%9B%BE%E7%89%87.png&originHeight=164&originWidth=305&originalType=binary&ratio=1&size=6376&status=done&style=none&taskId=ufdfe754c-80eb-472c-95ab-d93b08493c0&width=305)
<a name="PuB1j"></a>
#### 方式二  实现Runnable接口
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程
```java
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable() ;
        Thread t1 = new Thread(my,"飞机") ;
        Thread t2 = new Thread(my,"高铁") ;
        t1.start();
        t2.start();
    }
 }
************************************************************************************
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i+","+Thread.currentThread().getName());
        }
    }
}

方式二相比方式一有啥好处

避免Java单继承的局限性

适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。

/***************         common -->卖票<--        **************/
public class Demo {
  public static void main(String[] args) {
      SellTicket my = new SellTicket() ;
      Thread t1 = new Thread(my,"t1") ;
      Thread t2 = new Thread(my,"t2") ;
      Thread t3 = new Thread(my,"t3") ;
      t1.start();
      t2.start();
      t3.start();
  }
}

```java / 例子：卖票 / —>卖票<—

public class SellTicket implements Runnable{ private Integer ticket = 100 ;

@Override
public void run() {
    while(true){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+
                    "卖的第"+(100-ticket)+"票");
        }else {
            break;
        }
        ticket-- ;
    }
}

}

运行结果：会出现数据安全的问题，三个（多个）人卖同一张票的情况<br />![图片.png](https://cdn.nlark.com/yuque/0/2021/png/21763574/1623424532235-e039e90d-6f00-41e6-975c-1813f5727ba7.png#clientId=udda8f812-f6c4-4&from=paste&height=191&id=ua56396ff&margin=%5Bobject%20Object%5D&name=%E5%9B%BE%E7%89%87.png&originHeight=191&originWidth=191&originalType=binary&ratio=1&size=3730&status=done&style=none&taskId=u70623efe-5d5a-4b60-8a2b-40c81a3ad6a&width=191)
<a name="cRtXZ"></a>
## 9.3 数据安全问题
- 同步代码块
   - 锁多条语句操作共享数据
   - 格式：**_synchronized(任意对象){    多条语句操作共享数据的代码  }_**
   - synchronize(任意对象)：就相当于给代码加锁了，“任意对象”就可以看作是一把锁
   - 好处：解决了多线程的数据安全问题
   - 坏处：当线程很多的时候，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
```java
/* 例子：卖票-plus */
-->卖票<-- 
************************************************************************************
public class SellTicket implements Runnable{
    private Integer ticket = 100 ;
    private Object obj = new Object() ; //改动的地方
    @Override
    public void run() {
        while(true){
            synchronized (obj){   //改动的地方
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+
                            "卖的第"+(100-ticket)+"票");
                }else {
                    break;
                }
                ticket-- ;
                try {
                    Thread.sleep(100);   //改动的地方
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

同步方法：就是把synchronize关键字加到方法上，锁的对象是this ```java —>卖票<—

public class SellTicket implements Runnable{ private Integer ticket = 100 ; private Object obj = new Object() ; private int x = 0 ;

@Override
public void run() {
    while(true){
        synchronized (obj){
            if(x%2==0) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() +
                            "卖的第" + (100 - ticket) + "票");
                } else {
                    break;
                }
                ticket--;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                sellTicket();
            }
            x++ ;
        }
    }
}
public synchronized void sellTicket(){    //这就是格式
    if(ticket>0){
        System.out.println(Thread.currentThread().getName()+
                "卖的第"+(100-ticket)+"票");
    }
    ticket-- ;
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

}


- 同步静态方法：就是把synchronize关键字加到静态方法上，锁的对象是：类名.class
<a name="h5aZa"></a>
## 9.4 Lock锁
- 虽然可以理解同步代码和同步方法的锁对象问题，但是我们并没有直接看到在哪里上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。
- Lock实现提供比使用synchronize方法和语句可以获得更广泛的锁定操作，提供了获得锁和释放锁的方法
   - **_void lock()_**：获得锁
   - _**void unlock()**_：释放锁
- lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法。
   - **_ReentrantLock():_**创建一个ReentrantLock的实例
```java
-->卖票<-- 
************************************************************************************
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicket implements Runnable{
    private Integer ticket = 100 ;
    private Lock lock = new ReentrantLock() ;
    @Override
    public void run() {
        while(true){
            try {
            lock.lock();
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() +
                        "卖的第" + (100 - ticket) + "票");
            } else {
                break;
            }
            ticket--;
            Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
}

9.5 设置和获取线程名称

Thread类中设置和获取线程名称的方法
- void setName(String name) 将此线程的名称更改为等于参数name
- String getName() 返回此线程的名称
- 通过构造方法也可以设置线程名称（上面代码有示范）
如何获取main()方法所在的线程名称
- public static Thread currentThread() 返回对当前正在执行的线程对象的引用。（上面代码有示范）
  9.6 线程控制
static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join() 等待这个线程死亡
void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，java虚拟机将退出。

9.7 线程调度
线程有两种调度模型
- 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
- 抢占式调度模型：优化让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取CPU时间片相对多一些。（Java使用的）
Thread类中设置和获取线程优先级的方法
- public final int getPriority() 返回此线程的优先级
- public final void setPriority(int newPriority) 更改此线程的优先级
- 线程默认优先级是5，线程优先级范围是1-10
- 线程优先级高仅仅表示线程获取的CPU时间片几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果。 ```java public class Demo { public static void main(String[] args) { MyThread my1 = new MyThread(“高铁”) ; MyThread my2 = new MyThread(“飞机”) ; MyThread my3 = new MyThread(“汽车”) ;
  
  / my1.start(); my2.start(); my3.start();/
  
  System.out.println(); System.out.println(Thread.MAX_PRIORITY); System.out.println(Thread.MIN_PRIORITY); System.out.println(Thread.NORM_PRIORITY); System.out.println(); my1.setPriority(9); my2.setPriority(10); my3.setPriority(1); System.out.println(my1.getPriority()); System.out.println(my2.getPriority()); System.out.println(my3.getPriority()); } }

public class MyThread extends Thread{ public MyThread(String name) { super(name) ; } @Override public void run(){ for(int i=0;i<100;i++){ System.out.println(getName()+”,”+i); } } }

<a name="G1JHV"></a>
## 9.8 生产者消费者模式概述
- 是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻，所谓生产者消费者的问题，实际山主要是包含了两类线程
   - 一类是生产者线程用于生产数据
   - 一类是消费者线程用于消费数据
- 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
   - 生产者生产数据之后直接放置在共享数据区中，并不需要关心生产者行为
   - 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
- 为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法，在Object类中：
   - **_void wait() _** 导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法
   - _**void notify()**_  唤醒正在等待对象监视器的单个线程
   - _**void notifyAll()**_  唤醒正在等待对象监视器的所有线程
<a name="xL4QC"></a>
## 9.9 线程安全的类
- _**StringBuffer**_
   - 线程安全，可变的字符序列
   - 从版本JDK5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。
- **_Vector_**
   - 从java 2平台V1.2开始，该类改进了List接口，使其成为Java Collections Framwork的成员。与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector。
```java
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class Demo {
    public static void main(String[] args) {
//Set和List同理
        //List<String> list = new Vector<>();
        List<String> list = Collections.synchronizedList(new ArrayList<>()) ;
        //List<String> list = new CopyOnWriteArrayList<>() ;
        /*
         *CopyOnWrite 写入时复制，COW计算机程序设计的一种优化策略
         *多个线程调用的时候，list，读取的时候，固定的写入（覆盖）
         *在写入的时候避免重复覆盖，造成数据问题
         * 读写分离
         * CopyOnWriteArrayList 没有使用synchronize
         */
        for(int i=0;i<10;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(Thread.currentThread().getName()+"--"+list);
            },String.valueOf(i)).start();
        }
    }
 }

Hashtable
- 该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
- 从Java 2平台V1.2开始，该类进行了改进，实现Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable。

9.1 线程概述

9.2 多线程实现方式

方式一 继承Thread类

方式二相比方式一有啥好处

9.5 设置和获取线程名称

9.6 线程控制

9.7 线程调度

方式一继承Thread类