Java基础 - 12 - 多线程

线程（Thread）

        · 线程是一个程序内部的一条执行流程

        · 程序中如果只有一条执行流程，那么这个程序就是单线程的程序

多线程

        · 多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

       · 多线程的用途：12306购票、消息通信、购物系统等

一.多线程的创建

如何在程序中创建出多条线程？

        Java是通过java.lang.Thread类的对象来代表线程的

多线程的注意事项

        · 启动线程必须是调用start方法，不是调用run方法

        · 不要把主线程任务放在启动子线程之前

1.1 方式一：继承Thread类

多线程的创建方式一：继承Thread类

方式一优缺点

        优点：编码简单

        缺点：线程类已经继承Thread，无法继承其他类，不利于功能的拓展 

//demo
public class demo {//main方法是由一条默认的主线程负责执行public static void main(String[] args) {//创建MyThread线程类的对象代表一个线程Thread t = new MyThread();//启动线程（自动执行run方法）t.start(); //main线程 t线程for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出" + i + "次");}}
}//MyThread//让子类继承Thread线程类
public class MyThread extends Thread{//必须重写Thread类的run方法@Overridepublic void run() {//描述线程的执行任务for (int i = 1; i <= 5; i++) {System.out.println("子线程MyThread线程输出" + i + "次");}}
}

1.2 方式二：实现Runnable接口

多线程的创建方式二：实现Runnable接口

方式二优缺点

        优点：任务类只是实现接口，可以继续继承其他类，实现其他接口，扩展性强

        缺点：需要多一个Runnable对象

//demo
public class demo {//main方法是由一条默认的主线程负责执行public static void main(String[] args) {//创建任务对象Runnable target = new MyRunnable();//把任务对象交给一个线程对象处理//public Thread(Runnable target)new Thread(target).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程输出 ===>" + i);}}
}//MyRunnable
//定义一个任务类，实现Runnable接口
public class MyRunnable implements Runnable {//重写runnable的run方法@Overridepublic void run() {//线程要执行的任务for (int i = 1; i <= 5; i++) {System.out.println("子线程输出 ===>" + i);}}
}

线程创建方式二的匿名内部类写法

//demo
public class demo {//main方法是由一条默认的主线程负责执行public static void main(String[] args) throws Exception {//直接创建Runnable接口的匿名内部类形式Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程1输出 ===>" + i);}}};new Thread(target).start();//简化形式1new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程2输出 ===>" + i);}}}).start();//简化形式2new Thread(() -> {for (int i = 1; i <= 5; i++) {System.out.println("子线程3输出 ===>" + i);}}).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程输出 ===>" + i);}}
}

1.3 方式三：实现Callable接口

多线程的创建方式三：利用Callable接口、FutureTask类来实现

方式三优缺点

        优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程的执行结果

        缺点：编码复杂一些

//demo
public class demo {//main方法是由一条默认的主线程负责执行public static void main(String[] args) throws Exception {//创建一个Callable的对象Callable<String> call = new MyCallable(100);//把Callable的对象封装成一个FutureTask对象（任务对象）//未来任务对象的作用：//1.是一个任务对象，实现了Runnable接口//2.可以在线程执行完毕后，用未来任务对象调用get方法获取线程执行完毕后的结果FutureTask<String> f1 = new FutureTask<>(call);//把任务对象交给一个Thread对象new Thread(f1).start();Callable<String> call2 = new MyCallable(200);FutureTask<String> f2 = new FutureTask<>(call2);new Thread(f2).start();//获取线程执行完毕后返回的结果//注意：如果执行到这里，假如上面的线程还没有执行完毕，这里的代码会暂停，等待上面线程长记性完毕后才会获取结果String rs = f1.get();System.out.println(rs);String rs2 = f2.get();System.out.println(rs2);}
}//MyCallable
public class MyCallable implements Callable<String> {private int n;public MyCallable(int n){this.n = n;}//重写call方法@Overridepublic String call() throws Exception {//描述线程的任务，返回线程执行返回后的结果//需求：求1-n的和int sum = 0;for (int i = 0; i <= n; i++) {sum += i;}return "线程求出了1-" +n + "的和是：" + sum;}
}

二.Thread的常用方法

//demo
public class demo {public static void main(String[] args) {Thread t1 = new MyThread("1号线程");//t1.setName("1号线程");t1.start();System.out.println(t1.getName()); //1号线程Thread t2 = new MyThread("2号线程");//t2.setName("2号线程");t2.start();System.out.println(t2.getName()); //2号线程//主线程对象的名字Thread m = Thread.currentThread(); //哪个线程执行它，它就会得到哪个线程对象//m.setName("主线程");System.out.println(m.getName()); //主线程for (int i = 1; i <= 3; i++) {System.out.println("main线程输出：" + i);}}
}//demo2
public class demo2 {public static void main(String[] args) throws Exception {for (int i = 0; i <= 5; i++) {System.out.println(i);//休眠5sif(i == 3){Thread.sleep(5000);}}//join方法作用：让当前调用这个方法的线程先执行完Thread t1 = new MyThread("1号线程");t1.start();t1.join();Thread t2 = new MyThread("2号线程");t2.start();t2.join();Thread t3 = new MyThread("3号线程");t3.start();t3.join();}
}//MyThread//让子类继承Thread线程类
public class MyThread extends Thread{//    private String name;
//
//    public MyThread(String name){
//        this.name = name; //为当前线程设置名字
//    }public MyThread(String name){super(name); //为当前线程设置名字}//必须重写Thread类的run方法@Overridepublic void run() {Thread m = Thread.currentThread();//描述线程的执行任务for (int i = 1; i <= 3; i++) {System.out.println("子线程" + m.getName() + "输出：" + i);}}
}

Thread其他方法的说明

Thread类还提供了如：yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用。

三.线程安全

线程安全问题

        多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题

//demo
public class demo {public static void main(String[] args) {Account account = new Account(100000);new MyThread("小明", account).start();new MyThread("小红", account).start();}
}//MyThread
public class MyThread extends Thread{private Account account;public MyThread(){}public MyThread(String name, Account account) {super(name);this.account = account;}@Overridepublic void run() {//取钱account.qukuan(100000);}
}//Account
public class Account {private double balance; //余额public Account() {}public Account(double balance) {this.balance = balance;}public void qukuan(double money){//谁来取钱?String name = Thread.currentThread().getName();if(balance >= money){balance -= money;System.out.println(name + "取款" + money + "成功，账户余额：" + balance);}else{System.out.println("账户余额不足");}}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}
}

四.线程同步

线程同步

        解决线程安全问题的方案

线程同步的思想

        让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的常见方案

        加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

4.1 加锁的三种方式

4.1.1 方式一：同步代码块

        作用：把访问共享资源的核心代码给上锁，以此保证线程安全

        原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

同步锁的注意事项

        对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

——锁对象随便选择一个唯一的对象好不好？

    ——不好，会影响其他无关线程的执行

锁对象的使用规范

        建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象，对于静态方法建议使用字节码（类名.class）对象作为锁对象

public class Account {private double balance; //余额public Account() {}public Account(double balance) {this.balance = balance;}//多线程调用静态方法//建议用类名.class作为锁public static void test(){synchronized (Account.class){}}public void qukuan(double money){//谁来取钱?String name = Thread.currentThread().getName();//快捷键 CTRL+ALT+T//多线程调用实例方法//实例方法用this作为锁，this正好代表共享资源synchronized (this) {if(balance >= money){balance -= money;System.out.println(name + "取款" + money + "成功，账户余额：" + balance);}else{System.out.println(name + "取款失败，账户余额不足");}}}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}
}

4.1.2 方式二：同步方法

        作用：把访问共享资源的核心方法给上锁，以此保证线程安全

        原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

同步方法底层原理

        同步方法起始底层也是有隐式锁对象的，只是锁的范围是整个方法代码

        如果方法是实例方法，同步方法默认用this作为锁对象

        如果方法是静态方法，同步方法默认用类名.class作为锁对象

    //同步方法public synchronized void qukuan(double money){//谁来取钱?String name = Thread.currentThread().getName();//快捷键 CTRL+ALT+T//多线程调用实例方法//实例方法用this作为锁，this正好代表共享资源if(balance >= money){balance -= money;System.out.println(name + "取款" + money + "成功，账户余额：" + balance);}else{System.out.println(name + "取款失败，账户余额不足");}}

是同步代码块好一点还是同步方法好一点？

        范围上：同步代码块锁的范围更小，同步方法锁的范围更大

        可读性：同步方法更好

4.1.3 方式三：Lock锁

        Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大

        Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象

public class Account {private double balance; //余额//创建一个锁对象private final Lock lk = new ReentrantLock();public Account() {}public Account(double balance) {this.balance = balance;}public void qukuan(double money){//谁来取钱?String name = Thread.currentThread().getName();lk.lock(); //加锁try {if(balance >= money){balance -= money;System.out.println(name + "取款" + money + "成功，账户余额：" + balance);}else{System.out.println(name + "取款失败，账户余额不足");}} catch (Exception e) {e.printStackTrace();} finally {lk.unlock(); //解锁}}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}
}

五.线程通信

        当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺

线程通信的常见模型（生产者与消费者模型）

        生产者线程负责生产数据

        消费者线程负责消费生产者生产的数据

注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产

注意：上述方法应该使用当前同步锁对象进行调用

//demo
public class demo {public static void main(String[] args) {//创建一个桌子类Table t = new Table();//创建三个生产者线程（3个厨师）new Thread(new Runnable() {@Overridepublic void run() {while (true) {t.put();}}}, "厨师A").start();new Thread(() -> {while (true) {t.put();}}, "厨师B").start();new Thread(() -> {while (true) {t.put();}}, "厨师C").start();//创建两个消费者线程（3个顾客）new Thread(() -> {while (true) {t.get();}}, "顾客1").start();new Thread(() -> {while (true) {t.get();}}, "顾客2").start();}
}//Table
public class Table {private List<String> list = new ArrayList<>();//放一个包子的方法（厨师A 厨师B 厨师C）public synchronized void put() {try {String name = Thread.currentThread().getName();//判断桌子上是否有包子if(list.size() == 0){ //桌子上没包子list.add(name + "生产了一个包子");System.out.println(name + "生产了一个包子，放到桌子上");Thread.sleep(2000);//唤醒别人，等待自己this.notifyAll();this.wait();}else{ //桌子上有包子，厨师不用做了//唤醒别人，等待自己this.notifyAll();this.wait();}} catch (Exception e) {e.printStackTrace();}}//拿一个包子的方法（顾客1 顾客2）public synchronized void get() {try {String name = Thread.currentThread().getName();//判断桌子上是否有包子if(list.size() != 0){ //桌子上有包子list.remove(0);//list.clear();System.out.println(name + "消费了一个桌子上的包子");Thread.sleep(2000);//唤醒别人，等待自己this.notifyAll();this.wait();}else{ //桌子上没有包子，顾客不用吃包子//唤醒别人，等待自己this.notifyAll();this.wait();}} catch (Exception e) {e.printStackTrace();}}
}

六.线程池

        线程池是一个可以复用线程的技术

不使用线程池的问题

        用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能

线程池的工作原理

6.1 创建线程池

        JDK5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象？

        方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

        方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器

public ThreadPoolExecutor(int corePoolSize,

                                             int maximumPoolSize,

                                             long keepAliveTime,

                                             TimeUnit unit,

                                              BlockingQueue<Runnable> workQueue,

                                              ThreadFactory threadFactory,

                                              RejectedExecutionHandler handler)

        参数一：corePoolSize：指定线程池的核心线程的数量

        参数二：maximumPoolSize：指定线程池的最大线程数量

        参数三：keepAliveTime：指定临时线程的存活时间

        参数四：unit：指定临时线程存活的时间单位（秒、分、时、天）

        参数五：workQueue：指定线程池的任务队列

        参数六：threadFactory：指定线程池的线程工厂

        参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

线程池的注意事项

1.临时线程什么时候创建？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程

2.什么时候会开始拒绝新任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

6.3 线程池处理Runnable任务

新任务拒绝策略

//demo
public class demo {public static void main(String[] args) {//1.通过ThreadPoolExcutor创建一个线程池对象
//        public ThreadPoolExecutor(int corePoolSize,
//                                  int maximumPoolSize,
//                                  long keepAliveTime,
//                                  TimeUnit unit,
//                                  BlockingQueue<Runnable> workQueue,
//                                  ThreadFactory threadFactory,
//                                  RejectedExecutionHandler handler)
//        new ThreadPoolExecutor(3,5,8,
//                TimeUnit.SECONDS,new LinkedBlockingQueue<>(),Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());Runnable target = new MyRunnable();pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行的！pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);//临时线程的创建时机pool.execute(target);pool.execute(target);//到了新任务的拒绝时机pool.execute(target);//pool.shutdown(); //等着线程池的任务全部执行完毕后，再关闭线程池//pool.shutdownNow(); //立即关闭线程池！不管任务是否执行完毕}
}//MyRunnable
public class MyRunnable implements Runnable{@Overridepublic void run() {//任务是做什么的？System.out.println(Thread.currentThread().getName()+" ===> 输出666");try{Thread.sleep(Integer.MAX_VALUE);}catch (InterruptedException e) {e.printStackTrace();}}
}

6.4 线程池处理Callable任务

//demo
public class demo {public static void main(String[] args) throws Exception {//1.通过ThreadPoolExcutor创建一个线程池对象ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());//2.使用线程处理Callable任务Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));Future<String> f4 = pool.submit(new MyCallable(400));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}//MyCallable
public class MyCallable implements Callable<String> {private int n;public MyCallable(int n){this.n = n;}@Overridepublic String call() throws Exception {int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return Thread.currentThread().getName() + "线程求出了1-" + n + "的和是：" + sum;}
}

6.5 Executors工具类实现线程池

Executors

        是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

//demo
public class demo {public static void main(String[] args) throws Exception {//1.通过ThreadPoolExcutor创建一个线程池对象
//        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
//                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());//1.通过Executors创建一个线程池对象ExecutorService pool = Executors.newFixedThreadPool(3);//核心线程数量到底配置多少？//CPU核数：电脑的任务管理器（快捷键：ctrl+shift+esc）-性能-逻辑处理器数量//计算密集型的任务：核心线程数量 = CPU的核数 + 1//IO密集型的任务：核心线程数量 = CPU的核数 * 2//2.使用线程处理Callable任务Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));Future<String> f4 = pool.submit(new MyCallable(400));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}//MyCallable
public class MyCallable implements Callable<String> {private int n;public MyCallable(int n){this.n = n;}@Overridepublic String call() throws Exception {int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return Thread.currentThread().getName() + "线程求出了1-" + n + "的和是：" + sum;}
}

Executors使用可能存在的陷阱

        大型并发系统环境中使用Executors如果不注意可能会出现系统风险

  

七.并发、并行

进程

        · 正在运行的程序（软件）就是一个独立的进程

        · 线程是属于进程的，一个进程中可以同时运行很多个线程

        · 进程中的多线程其实是并发和并行执行的

并发的含义

        进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

        在同一时刻上，同时有多个线程在被CPU调度执行

八.线程的生命周期

        线程的生命周期：线程从生到死的过程中，经历的各种状态及状态转换

Java线程的状态

        Java共定义了6种状态，都在Thread类的内部枚举类中

public class Thread{……public enum State {NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;}……
}

线程的6种状态互相转换 

线程的6种状态总结

九.悲观锁和乐观锁

悲观锁和乐观锁
        悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，再解锁。

                        线程安全，但性能较差

        乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。

                         线程安全，性能较好

public class demo {public static void main(String[] args) {//悲观锁和乐观锁//悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，再解锁。 线程安全，但性能较差//乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。 线程安全，性能较好//需求：1个变量，100个线程。每个线程对其加100次Runnable target = new MyRunnable();for (int i = 1; i <= 100; i++) {new Thread(target).start();}}
}//悲观锁
public class MyRunnable implements Runnable{private int num; //记录浏览人次@Overridepublic void run() {for (int i = 0; i < 100; i++) {synchronized (this){System.out.println(Thread.currentThread().getName() + " num ==>" + (++num));}}}
}//乐观锁
public class MyRunnable implements Runnable{//整数修改的乐观锁：原子类实现的private AtomicInteger count = new AtomicInteger();@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + " num ==>" + count.incrementAndGet());}}
}

十.案例

//demo
public class demo {public static void main(String[] args) throws InterruptedException {List<String> gifts = new ArrayList<>();String[] names = {"化妆品","鲜花","包包","皮带","鞋子","衬衣"};Random r = new Random();for (int i = 1; i <= 100; i++) {gifts.add(i + "号礼物：" + names[r.nextInt(names.length)]);}System.out.println(gifts);//定义线程类，创建线程对象，去集合中拿礼物SendThread xm = new SendThread(gifts,"小明");xm.start();SendThread xh = new SendThread(gifts,"小红");xh.start();xm.join();xh.join();System.out.println(xm.getCount());System.out.println(xh.getCount());}
}//SendThread
public class SendThread extends Thread{private List<String> gifts;private int count;public SendThread(List<String> gifts, String name){super(name);this.gifts = gifts;}@Overridepublic void run() {String name = Thread.currentThread().getName();Random r = new Random();while(true){synchronized (gifts){if(gifts.size()<10){break;}String rs = gifts.remove(r.nextInt(gifts.size()));System.out.println(name + "发出了" + rs);count++;}}}public int getCount() {return count;}public void setCount(int count) {this.count = count;}
}