【一看就懂的java学习】高级篇 之 多线程

进程和线程

进程

是正在运行的程序

• 是系统进行资源分配和调用的独立单位
• 每一个进程都有它自己的内存空间和系统资源

线程

是进程中的单个顺序控制流，是一条执行路径

• 单线程;一个进程如果只有一条执行路径，则成为单线程程序
• 多线程：一个进程如果有多条执行路径，则成为多线程程序

举例：

• 记事本设置打开后不能再进行输入操作，说明是单线程
• 游戏中的计时和游戏进行是两个线程

实现多线程

多线程的实现方式（一）

方式一：继承Thread类

• 定义一个类MyThread继承Thread类
• 在MyThread类中重写run()方法
• 创建MyThread类的对象
• 启动线程
  
  
  在一个循环没到99时另一个也开始了。但是也有一个结束后另一个才开始的可能。

两个小问题：

• 为什么重写run()方法
  • 因为run()是用来封装被线程执行的代码
• start()方法和run()方法的区别
  • 启动线程；然后由JVM调用此线程的run()方法

设置和获取线称

Thread类中设置和获取线程名称的方法

• void setName(String name):将此线程的名称更改为等于参数name
• String getName():返回此线程的名称
• 通过构造方法也可以设置线程名称

如何获取main()方法所在的线程名称

• public static Thread currentThread():返回对当前正在执行的线程对象的引用
  
  

线程调度

线程由两种调度模型

• 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
• 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些
• Java使用的是抢占式调度模型

假如计算机只有一个CPU，那么CPU在某时刻只能执行一条指令，线程只有得到CPU时间片，即使用权，才可以执行指令。故多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

Thread类中设置和获取线程优先级的方法

• public final int getPriority()：返回此线程的优先级
• public final void setPriority(int newPriority)：更改此线程的优先级

线程默认优先级是5；范围是1-10
线程优先级高仅仅表示线程获取CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

线程控制

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个线程死亡
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

sleep:


join:


父执行完，兄弟才执行

setDaemon：



守护线程执行完毕后，其他线程也很快结束，但不是立即消失

线程生命周期

多线程的实现方式（二）

方式2：实现Runnable接口

• 实现一个类MyRunnable实现Runnable接口
• 在MyRunnable类中重写run()方法
• 创建MyRunnable类的对象
• 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
• 启动线程

多线程的实现方案有两种

• 继承Thread类
• 实现Runnable接口

相比继承Thread类，实现Runnable接口的好处

• 避免了Java单继承的局限性
• 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

线程同步

一些问题

在多个线程的程序运行时，使用sleep()方法后，会产生问题：

• 相同的数字出现多次
• 出现了负数
  原因：
• 线程执行的随机性导致的

数据安全问题的解决

多线程程序是否有数据安全问题的标准：

• 是否有多线程环境
• 是否有共享数据
• 是否有多条语句操作共享数据

如何解决多线程安全问题：

• 基本思想：让程序没有安全问题的环境

如何实现：

• 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
• Java提供了同步代码块的方式来解决

同步代码块

锁多条语句操作共享数据，可以使用同步代码快实现

• 格式：
  synchronized(任意对象){
  多条语句操作共享数据的代码
  }
  任意对象就相当于一个锁，可以是设定每个线程一把锁，也可以设定多个线程一把锁
• synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

好处和坏处：

• 好处：解决了多线程的数据安全问题
• 坏处：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

同步方法

同步方法：就是把synchronized关键字加到方法上

• 格式：
  修饰符 synchronized 返回值类型 方法名(方法参数){ }
  同步方法的锁是：
• this

同步静态方法：就是把synchronized关键字加到静态方法上

• 格式：
  修饰符 static synchronized 返回值类型 方法名(方法参数){ }
  同步静态方法的锁对象是：
• 类名.class
  静态方法的锁与类相关，要利用反射，类名.class获取该类的字节码文件对象。这就是静态方法的锁

线程安全的类

StringBuffer

• 线程安全，可变的字符序列
• 从JDK 5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

Vector

• 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector

Hashtable

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

可以通过查看各个对象的方法来验证是否线程安全

Lock锁

虽然可以理解同步代码块和同步方法的锁对象问题，但是没有直观的看到在哪里上了锁，在哪里释放了锁，为了更清晰表达如何加锁与释放锁，JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法

• void lock()：获得锁
• void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法

• ReentrantLock（）：创建一个ReentrantLock的实例
  

生产者消费者

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻
所谓生产者消费者问题，实际上主要是包括了两类线程：

• 一类是生产者线程用于生产数据
• 一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

• 生产者生产数据后直接放置在共享数据区中，并不需要关心消费者的行为
• 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中
Object类的等待和唤醒方法：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

案例：

• 奶箱类（Box）:定义了一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
• 生产者类（Producer）：实现Runnable接口，重run()方法，调用存储牛奶的操作
• 消费者类（Customer）：实现Runnable接口，重写run()方法，调用获取牛奶的操作
• 测试类（BoxDemo）：里面有main方法，main方法中的代码步骤如下
  • 创建奶箱对象，这是共享数据区域
  • 创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
  • 创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类要调用获取牛奶的操作
  • 创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
  • 启动线程

Box类：

public class Box {
//    定义了一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量表示奶箱的状态
    private boolean state = false;

//    提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk){
        //如果有牛奶，等待消费
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶就生产牛奶
        this.milk=milk;
        System.out.println("送奶工将第"+this.milk+"瓶牛奶放入奶箱");

        //生产完毕后，修改奶箱状态
        state=true;

        //唤醒其他等待的线程
        notifyAll();
    }
    public synchronized void get(){
        //如果有牛奶，等待生产
        if (!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第"+this.milk+"瓶牛奶");

        //消费完毕后，修改奶箱状态
        state=false;
        //唤醒其他等待的线程
        notifyAll();
    }
}

Producer类：

public class Producer implements Runnable {
    private final Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            b.put(i);
        }
    }
}

Customer类：

public class Customer implements Runnable {
    private final Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

BoxDemo类：

public class BoxDemo {
    public static void main(String[] args) {
//        创建奶箱对象，这是共享数据区域
        Box b = new Box();
//        创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
//        创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类要调用获取牛奶的操作
        Customer c = new Customer(b);
//        创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        //启动线程
        t1.start();
        t2.start();
    }
}