Java进阶（一）-多线程

1.基本概念：程序、进程、线程

• 程序（program）：为了完成特定任务、用某种语言编写的一组指令的集合。即一段静态的代码，静态对象。

• 进程（process）:正在运行的一个程序，是一个动态的过程，有自己的产生、存在和消亡的过程。-生命周期。

  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域；

• 线程（thread）：进程可以进一步细分为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的；
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）,线程切换的开销小。
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间，也就是它们从同一堆中分配对象，可以访问相同的变量和对象。这就是的线程间通信更简单、高效，但是多个线程操作共享系统资源就可能回带来安全隐患。

• 多线程程序的优点：1.提高应用程序的响应；2.提高计算机系统CPU的利用率；

3.改善程序的结构，将长有2复杂的进程分为多个线程，独立运行，有助于理解和修改。

• 何时需要多线程：1.程序需要同时执行两个或多个任务；2.程序需要实现一些需要等待的任务时，比如，用户输入、文件读写操作、网络操作、搜索等；3.需要一些后台运行的程序时。

2.线程的创建和使用

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。Thread类的特性：①每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体；②通过Thread对象的start()方法来启动这个线程，而不是直接调用run().

多线程的创建方式1——继承于Thread类

/*多线程的创建：方式一：继承于Thread类
1.创建优格继承于Thread类的子类
2.重写Thread类中的run()--将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象  -在主线程中创建
4.通过此对象调用start()
*例子：遍历100以内所有偶数
* */
//1.
class MyThread extends Thread{
    @Override
    //2.
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.print(i+" ");
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.
        MyThread mT1= new MyThread();
        //4.
        mT1.start(); //该方法作用①启动当前线程；②调用当前线程中的run()方法
        //问题一：注意不能直接调用run()来启动线程
        //问题二：如果需要再创建一个线程，需要再new一个的线程的对象，要想创建多个线程，就需要创建多个对象。
        MyThread mT2= new MyThread();
        mT2.start();
        //如下操作仍然时在main线程中执行的
        for (int i = 0; i < 100; i++) {   //此时有两个线程，结果交替输出
            if(i%2!=0){
                System.out.println("*"+i);
            }
        }
    }
}

Thread类常用方法

• void start():启动线程，并执行对象的run()方法；
• run():线程在被调度时执行的操作；
• String getName(); 返回线程的名称
• void setName(String name):设置该线程的名称
• static Thread.currentThread():返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类
• yield() 释放当前cpu的执行权
• join() 在线程A中调用线程b的方法join(),此时线程a就被阻塞，直到线程b完全执行广域完以后，线程a才结束阻塞状态
• stop() 强制线程生命期结束，已经过时。
• boolean isAlive() 返回boolean,判断线程是否还活着
• static void sleep(long millitime):让当前线程睡眠指定的millitime毫秒，在指定毫秒时间内，当前线程时阻塞状态

线程的调度

cpu的调度策略是通过时间片或者是抢占式（高优先级的线程抢占CPU）。Java的调度方法：①同优先级线程组成先进先出队列（先到先服务），使用时间片策略；②对高优先级，使用优先调度的抢占式策略。

• 线程的优先级等级

  • MAX_PRIORITY:10
  • MIN_PRIORITY:1
  • NORM_PRIORITY:5 --->默认优先级

• 涉及的方法

  • getPriorty():返回线程优先值
  • setPriority（int newPriority）:改变线程的优先级

• 说明

  • 线程创建时继承父线程的优先级
  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

多线程的创建方式2——实现Runnable接口

/*
* 创建多线程的方式二：实现Runnable接口
* 1.创建一个类实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法:run()
* 3.创建实现类的对象
* 4.将此对象的参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
*
* */
//1.
class MThread implements Runnable{
//2.
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadCreate2 {
    public static void main(String[] args) {
        //3.
        MThread mThread = new MThread();
        //4.将此对象的参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5.通过Thread类的对象调用start():①启动线程②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.setName("线程1");
        t1.start();

        //再启动一个线程，实现一样的功能
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

两种多线程的创建方式的比较

• 开发中，优先选择实现Runnable接口的方式

  • 1. 实现的方式没有类的单继承性的局限性
    2. 实现的方式更适合来处理多个线程有共享数据的情况

• 联系：

  • 两种方式都需要重写run()方法

3.线程的生命周期

• JDK中使用了Thread.State类定义了线程的几种状态。

  要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Threasd类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

  • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建的状态；
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是还没分配到CPU的资源
  • 运行：当就绪的线程被调度并获得CPU资源时，便进入了运行状态，run()方法定义了线程的操作和功能；
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态；
  • 死亡：线程完成了它的全部工作或线程被提前强制中止或出现异常导致结束。

4.线程的同步--解决线程的安全性问题

方式一：同步代码块

package com.thread;

/*
 * 例子：创建三个窗口卖票，总票数100张，使用Runnable接口方式实现
 * 1.卖票过程中，出现了重票、错票--->出现了线程安全问题；
 * 2.在Java中，我们通过同步机制，来解决线程的安全问题；
 * 方式一：同步代码块
 * synchronized(同步监视器){
 * //需要被同步的代码
 * }
 * 说明：1.操作共享数据的代码，即为需要被同步的代码
 * 2.共享数据：多个线程共同操作的变量。即这里的ticket就是共享数据
 *3.同步监视器，俗称：锁。任何一个类的对象都可以充当锁.
 *               要求：多个线程必须要共用同一把锁。
 *补充，在用Runnable接口创建多线程问题中，可以考虑用this充当锁；
 * 在继承Thread创建多线程中，慎用this充当同步监视器，考虑当前类充当同步监控器
 *
 * 4.同步的方式，解决了线程的安全问题。但是操作同步代码时，只能有一个线程参与，
 * 其他线程等待，相当于一个单线程的过程，效率低。
 *
 *
 * */
class WindowT2 implements Runnable{

    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true) {

            //正确的方式
            //synchronized (obj) {
            synchronized (this){//this唯一
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowsTest2 {
    public static void main(String[] args) {
        WindowT2 wt2 = new WindowT2();
        Thread h1 = new Thread(wt2);
        Thread h2 = new Thread(wt2);
        Thread h3 = new Thread(wt2);
        h1.setName("窗口1");
        h1.start();
        h2.setName("窗口1");
        h2.start();
        h3.setName("窗口1");
        h3.start();
    }

}

方式二：同步方法

/*使用同步方法解决Runnable接口方式实现多线程问题
*关于同步方法的总结
* 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明；
* 2.非静态的同步方法，同步监视器是：this
* 3.静态的同步方法，同步监视器是：当前类本身
* */
class WindowT3 implements Runnable{

    private int ticket=100;
    @Override
    public void run() {
        while (true) {
            show();
            }
        }
        private synchronized void   show(){   //同步方法，同步监视器就是:this
            if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                ticket--;
            }
        }
    }

public class WindowsTest3 {
    public static void main(String[] args) {
        WindowT3 wt3= new WindowT3();
        Thread h1 = new Thread(wt3);
        Thread h2 = new Thread(wt3);
        Thread h3 = new Thread(wt3);
        h1.setName("窗口1");
        h1.start();
        h2.setName("窗口1");
        h2.start();
        h3.setName("窗口1");
        h3.start();
    }
}

方式三：Lock同步锁

• 从JDK5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

/*
* 解决线程安全问题的方式三：---lock锁---JDK5.0新增
*
* 1.面试题：synchronized和lock异同？
* 相同：二者都可以解决线程安全问题
* 不同：synchronized机制在执行完相应的同步代码以后，自动释放同步监视器；
* lock需要手动的启动同步（lock()）,同时结束同步也需要手动实现（unlock()）
*2.面试题：如何解决线程安全问题，有几种方式？三种
* */
class  WindowL implements Runnable{

private int ticket=100;
//实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock();  //如果使用继承方式创建多线程，这里需要加一个static
    @Override
    public void run() {
     while(true){
         try{
            //2.调用lock()
             lock.lock();
             if(ticket>0){
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println(Thread.currentThread().getName()+":售票，票号为："+ticket);
                 ticket--;
             }else{
                 break;
             }
         }finally {
             //3.调用解锁的方法
             lock.unlock();
         }
     }
    }
}
public class LockTest {
    public static void main(String[] args) {
        WindowL t = new WindowL();
        Thread h1=new Thread(t);
        Thread h2=new Thread(t);
        Thread h3=new Thread(t);

        h1.setName("窗口1");
        h2.setName("窗口2");
        h3.setName("窗口3");
        h1.start();
        h2.start();
        h3.start();
    }
}

synchronized与Lock的对比

1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放；
2. Lock只有代码块锁，synchronized有代码块和方法锁；
3. 使用lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）

优先使用顺序

Lock->同步代码块（已经进入了方法体，分配了相应的资源）->同步方法（在方法体之外）

线程的死锁问题

• 死锁理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，这就形成了线程的死锁；

• 说明：

  1. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续；
  2. 我们使用同步时，要避免死锁。

• 解决方法：

  1. 专门的算法、原则
  2. 尽量减少同步资源的定义
  3. 尽量避免嵌套同步

例子：

/*银行有一个账户，有两个储户分别向同一个账户存3000元，每次存，存3次。
* 分析：
* 1.是否有多线程问题？是，有两个储户
* 2.是否有共享数据?有，账户（或者是账户余额）
* 3.是否有线程安全问题？有
* 4.需要考虑如何解决线程安全问题？同步机制：三种方式
*
* */

class Account{
    private  double balance;

    public Account(double balance) {  //构造器
        this.balance = balance;
    }
    //存钱
    public synchronized void deposit(double amt){
        if(amt>0){
            balance+=amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"存钱成功。余额为："+balance);
        }
    }
}
class Customer extends Thread{
    private  Account acct;

    public Customer(Account acct) {
        this.acct = acct;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acct.deposit(1000);
        }
    }
}
public  class AccountTest {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer customer1 = new Customer(account);
        Customer customer2 = new Customer(account);
        customer1.setName("甲");
        customer2.setName("乙");
        customer1.start();
        customer2.start();
    }
}

5.线程的通信

/*线程通信的例子：使用两个线程打印1-100，线程1和线程2交替使用
涉及到三个方法：
wait()：一旦执行该方法，当前线程就会进入阻塞状态并释放同步监视器；
notify()：一旦执行该方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级高的
notifyAll():一旦执行此方法，就会唤醒所有被wait()的线程
说明：
1.以上三种方法必须使用在同步代码块或同步方法中；
2.以上三种方法的调用者必须是同步代码块或同步方法中的同步监视器；
否则，会出现IllegalMonitorStateException异常
*3.以上三种方法是定义在java.lang.Object类中；
* */

class Number implements Runnable{
  private  int number=1;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify();   //其中一个线程唤醒另一个线程
                //一个线程唤醒多个线程
            if(number<=100){
                System.out.println(Thread.currentThread().getName()+":"+number);
                number++;
                try {
                    //使得调用如下wait（）方法的线程进入阻塞状态
                    wait();  //会释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                break;
            }
        }
        }
    }
}
public class ThreadCommunication {
    public static void main(String[] args) {
        Number number = new Number();
        Thread h1=new Thread(number);
        Thread h2=new Thread(number);
        h1.setName("线程1");
        h2.setName("线程2");
        h1.start();
        h2.start();
    }
}

面试题：sleep()和wait()的异同？

相同点：一旦执行该方法，都可以使得当前的线程进入阻塞状态；

不同点：1. 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait();

2.调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或者同步方法中；

3.关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，而wait()会释放锁。

综合性经典问题：生产者/消费者问题

/*
* 线程通信的应用：经典例题：生产者消费者问题
* 生产者将产品交给店员，而消费者从店员处取走产品，店员一次只能持固定
* 数量的产品（比如20），如果生产者试图生产更多的产品，店员会叫停一下，
* 如果店中有空位了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下
* 如果店总有了产品再通知消费者来取走商品
*分析：
* 1.是否有多线程问题？是，生产者线程，消费者线程
* 2.是否有共享数据？是，店员（或产品）
* 3.如何解决线程的安全问题？同步机制三种方式
* 4.是否涉及到通信？是
* */
//消费者类
class Clerk{
    private int productCount=0;
//生产和消费不能同时使用，否则会产生线程安全问题，所以线程安全的处理主要在店员这块
    //生产产品
    public synchronized void produceProduct() {
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+"：开始生产第"+productCount+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if(productCount>0) {
            System.out.println(Thread.currentThread().getName()+"：开始消费第"+productCount+"个产品");
            productCount--;

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}
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(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();

        }
    }
}
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(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();

        }
    }
}
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");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

6.JDK5.0新增线程创建方式

新增方式一：实现Callable接口

• 与使用Runnable相比，Callable功能更强大些
  1. 相比run()方法，可以有返回值
  2. 方法可以抛出异常；
  3. 支持泛型的返回值
  4. 需要借助Future Task类，比如获取返回结果
     • Future接口
       • 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等；
       • FutureTask是Future接口的唯一的实现类；
       • FutureTask同时实现了Runnable、Callable接口哦，它既可以作为Runnable被线程执行；又可以作为Future得到Callable的返回值。

/*
*创建线程的方式三：实现callable接口---JDK5.0新增
*如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建的多线程方式更强大？
* 1.call()方法可以又返回值；
* 2.call()方法可以抛出异常，被外面操作捕获，获取异常的信息
* 3.Callable支持泛型
* */

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable接口的实现类
class  NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()方法中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i <=100; i++) {
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum; //自动装箱
    }
}
public class ThreadNewCall {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数作为Thread类的构造器中，创建Thread对象并调用start()方法
        new Thread(futureTask).start();
        try {
            //6.获取Callable中的call()方法的返回值，可要可不要
            //get()返回值即为 FutureTask构造器参数Callable实现类重写的call()的返回值
           Object sum= futureTask.get();
            System.out.println("总和为"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

新增方式二：使用线程池

• 思路：提前创建号多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用，类似生活中的公交交通工具；

• 好处：

  • 提高响应速度（减少了创建新的线程的时间）；
  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）；
  • 便于线程管理
    • corePoolSize:核心池的大小
    • maximumPoolSize:最大线程池
    • keepAliveTime:线程没有任务时最多保持多久时间后会终止

• 线程池相关API

  JDK5.0起提供了线程池相关的API：ExecutorService和Executors

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runnable command):执行任务或命令，没有返回值，一般用来执行Runnable
    • Futuresubmit(Callabletask):执行任务，有返回值，一般用来执行Callable
    • void shutdown():关闭连接池

  • Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

    • Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池；
    • Executors.newFixedThreadPool(n):创建一个可重用固定线程的线程池；
    • Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池；
    • Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/*
* 创建线程的方式四：使用线程池
* */
class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
    }
}
class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //设置线程池的属性
       // System.out.println(service.getClass());
     //   service1.setCorePoolSize(15);
      //  service1.setKeepAliveTime(11);

        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合使用于Runnable
        service.execute(new NumberThread1());//适合使用于Runnable
       // service.submit(Callable callable);//适合使用于Callable
        //3.关闭线程池
        service.shutdown();
    }
}

面试题：创建多线程有几种方式？四种！