Java基础-多线程

目录

• 线程
  • 1、Thread
    • 1. 1 创建线程第一种方法-继承Thread
    • 1.2 创建线程的第二种方法-实现Runnable
    • 1.3 两者对比
  • 2、案例
    • 2.1 龟兔赛跑
    • 2.2 多线程下载图片
  • 3、静态代理
  • 4、Lambda表达式
    • 4.1 定义
  • 5、线程五大状态
    • 5.1 五大状态转换关系
    • 5.2 停止线程
    • 5.3 线程休眠
    • 5.4 线程礼让-yield
    • 5.5 Join
    • 5.6 线程状态
    • 5.7 线程优先级
    • 5.8 守护（daemon）线程
  • 6、线程同步
    • 6.1 队列和锁
    • 6.2 同步方法
    • 6.3 死锁
    • 6.4 Lock(锁)
    • 6.5 synchronized 与 Lock的对比
  • 7、线程通信
    • 7.1 图片：
    • 7.2 管程法
    • 7.3标志位法
    • 7.4使用线程池

线程

1、Thread

• 线程就是独立执行的路径；
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
• main()称之为主线程，为系统的入口，用于执行整个程序；
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致；

1. 1 创建线程第一种方法-继承Thread

1. 自定义线程类继承Thread类。
2. 重写run() 方法，编写线程执行体。
3. 创建线程对象，调用start() 方法启动线程。
4. 线程不一定立即执行，CPU安排调度，同main方法里面的操作是同时进行的，即穿插执行。图片插入：
5. 代码：

package com.ruixi.thread;
/**
 * @Author: ruixi
 * @Date: 2021/1/24 14:35
 */
//创建线程方式一：继承Thread类，重写run()方法，调用start()方法
public class TestThread1 extends Thread{
        //线程入口点
        @Override
        public void run(){
                //run方法线程体
                for(int i = 0; i < 200; i++){
                        System.out.println("我在看代码----"+i);
                }
        }
        public static void main(String[] args) {
                //main线程，主线程
                //创建一个线程对象
                TestThread1 testThread1 = new TestThread1();
                //调用start()方法开启线程
                testThread1.start();
                for(int i = 0; i < 1000; i++){
                        System.out.println("我在学习多线程--"+i);
                }
        }
}

1.2 创建线程的第二种方法-实现Runnable

1. 定义MyRunnable类实现Runnable接口
2. 实现run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程
4. 推荐使用Runnable对象，因为Java单继承的局限性
5. 代码：

package com.ruixi.thread;

/**
 * @Author: ruixi
 * @Date: 2021/1/24 15:58
 */
public class TestThread3 implements Runnable{
        @Override
        public void run() {
                for(int i = 0; i < 200; i++){
                        System.out.println("我在看代码---"+i);
                }
        }

        public static void main(String[] args) {
                //创建runnable接口的实现类对象
                TestThread3 testThread3 = new TestThread3();
                //创建线程对象，通过线程对象来开启我们的线程，代理
                new Thread(testThread3).start();

                for(int i = 0; i < 1000; i++){
                        System.out.println("我在学习多线程--"+i);
                }
        }
}

1.3 两者对比

1. 继承Thread类
   • 子类继承Thread类具备多线程能力
   • 启动线程：子类对象.start()
   • 不建议使用：避免OOP单继承局限性
2. 实现Runnable接口
   • 实现接口Runnable具备多线程能力
   • 启动线程：传入目标对象+Thread对象.start()
   • 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用。

2、案例

2.1 龟兔赛跑

• 代码：

package com.ruixi.thread;

/**
 * @Author: ruixi
 * @Date: 2021/1/24 16:23
 */
//模拟龟兔赛跑
public class Race implements Runnable{
        //胜利者
        private static String winner;

        @Override
        public void run() {
                for(int i = 0; i <= 100; i++){
                        //模拟兔子休息
                        if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                                try {
                                        Thread.sleep(1);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                        boolean flag = gameOver(i);
                        if(flag){
                                break;
                        }
                        System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
                }
        }
        //判断是否完成了比赛
        private boolean gameOver(int steps){
                if(winner  != null){
                        return true;
                }else{
                        if(steps >= 100){
                                winner  = Thread.currentThread().getName();
                                System.out.println("Winner is " + winner);
                                return true;
                        }
                }
                return false;
        }

        public static void main(String[] args) {
                Race race = new Race();

                new Thread(race, "兔子").start();
                new Thread(race, "乌龟").start();
        }
}

2.2 多线程下载图片

• 代码：

package com.ruixi.thread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * @Author: ruixi
 * @Date: 2021/1/24 15:01
 */
//实现Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{
        private String url;
        private String name;

        public TestThread2(String url, String name) {
                this.url = url;
                this.name = name;
        }

        @Override
        public void run(){
                WebDownloader webDownloader = new WebDownloader();
                webDownloader.downloader(url, name);
                System.out.println("下载了文件名为："+name);
        }
        public static void main(String[] args) {
                TestThread2 t1 = new TestThread2("https://i0.hdslb.com/bfs/album/2f73e046e279ea0ac4ef827a96bdc73fbebb1ec2.png@518w.png", "1.png");
                TestThread2 t2 = new TestThread2("https://i0.hdslb.com/bfs/album/bedfcffb2d7f2e1664a48437a8c243e41418a223.jpg@518w.jpg", "2.jpg");
                TestThread2 t3 = new TestThread2("https://i0.hdslb.com/bfs/album/7e67b4217347a7bfad061cfa44ab6f01820fd12e.jpg@518w.jpg", "3.jpg");

                t1.start();
                t2.start();
                t3.start();
        }
}
class WebDownloader{
        public void downloader(String url, String name){
                try{
                        FileUtils.copyURLToFile(new URL(url), new File(name));
                }catch(IOException e){
                        e.printStackTrace();
                        System.out.println("文件下载失败");
                }
        }
}

3、静态代理

1. 真实对象和代理对象都要实现同一个接口
2. 代理对象要代理真实角色
3. 好处：
   • 代理对象可以做很多真实对象做不了的事情
   • 真实对象专注于做自己的事情
4. 代码：

package com.ruixi.thread;
/**
 * @Author: ruixi
 * @Date: 2021/1/24 17:40
 */
public class StaticProxy {
        public static void main(String[] args) {
                WeddingCompany weddingCompany = new WeddingCompany(new You());
                weddingCompany.HappyMarry();
        }
}
interface Marry{
        void HappyMarry();
}
//真实角色
class You implements Marry{
        @Override
        public void HappyMarry() {
                System.out.println("学习使我快乐！！！");
        }
}
//代理角色
class WeddingCompany implements Marry{
        private Marry target;
        public WeddingCompany(Marry target) {
                this.target = target;
        }
        @Override
        public void HappyMarry() {
                before();
                this.target.HappyMarry();
                after();
        }
        private void before(){
                System.out.println("黎明前的黑暗！！！");
        }
        private void after(){
                System.out.println("苦尽甘来！！！");
        }
}

4、Lambda表达式

4.1 定义

1. 是希腊字母表中排序第十一位的字母，英文名为Lambda。
2. 避免匿名内部类定义过多。
3. 其实质属于函数式编程的概念。
4. 函数式接口的定义：
   • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
   • 对于函数式接口，我们可以通过lambda表达式来创建该接口对象。
5. 总结：
   • lambda表达式只能有一行代码的情况下才能简化成一行，有多行的情况下要使用代码块包裹。
   • 前提是接口为函数式接口。
   • 多个参数也可以去掉参数类型，要去掉就都去掉，必须加括号。

5、线程五大状态

5.1 五大状态转换关系

• 图片：
  

5.2 停止线程

1. 不推荐使用JDK提供的stop()、destroy()方法。
2. 推荐线程自己停下来。
3. 建议使用一个标志位进行终止变量当flag = false, 则终止线程运行。
4. 代码：

package com.ruixi.thread;

/**
 * @Author: ruixi
 * @Date: 2021/1/24 20:02
 */
public class TestStop implements Runnable{
        //1. 设置标志位
        private boolean flag = true;
        @Override
        public void run() {
                int i = 0;
                while(flag){
                        System.out.println("run...Thread"+i++);
                }
        }
        //2. 设置一个公开的方法停止线程，转换标志位
        public void stop(){
                this.flag = false;
        }

        public static void main(String[] args) {
                TestStop testStop = new TestStop();
                new Thread(testStop).start();

                for(int i = 0; i < 1000; i++){
                        System.out.println("main"+ i);
                        if(i == 900){
                                testStop.stop();
                                System.out.println("线程结束了！！！");
                        }
                }
        }
}

5.3 线程休眠

1. sleep(时间)指定当前线程阻塞的毫秒数。
2. sleep存在异常InterruptedException。
3. sleep时间到达后线程进入就绪状态。
4. sleep可以模拟网络延时，倒计时等。
5. 每个对象都有一个锁，sleep不会释放锁。

5.4 线程礼让-yield

1. 礼让线程，让当前正在执行的线程暂停，但是不阻塞。
2. 将线程从运行状态转为就绪状态。
3. 让CPU重新调度，礼让不一定成功，看CPU心情。

5.5 Join

1. Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。
2. 类似于插队。

5.6 线程状态

1. 一旦线程中断或者结束，就进入死亡状态，就不能再次启动。
2. thread.getState() 方法。
3. 图片：

5.7 线程优先级

1. Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有进程，线程调度器按照优先级决定应该调度哪个线程来执行。
2. 线程的优先级用数字表示，范围从1~10。
   • Thread.MIN_PRIORITY = 1;
   • Thread.MAX_PRIORITY = 10;
   • Thread.NORM_PRIORITY = 5;
3. 使用以下方法改变或获取优先级
   • getPriority();
   • setPriority(int xxx);
4. 优先级的设定建议在start()调度前。
5. 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这些都是看CPU的调度。

5.8 守护（daemon）线程

1. 线程分为用户线程和守护线程。
2. 虚拟机必须确保用户线程执行完成。
3. 虚拟机不用等待守护线程执行完毕。
4. 如：后台记录操作日志，监控内存，垃圾回收等待。

6、线程同步

• 并发：同一个对象被多个线程同时操作。

6.1 队列和锁

1. 在访问时加入锁机制（synchronized）,当一个线程获得对象的排它锁，独占资源，其他线程必须等待。
2. 存在问题：
   • 一个线程持有锁会导致其他需要此锁的线程挂起；
   • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
   • 如果一个优先级高的等待线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题；

6.2 同步方法

1. 这套机制就是synchronized 关键字。
2. synchronized方法和synchronized块。
   • 同步方法：public synchronized void method(int args){}
   • synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行；
   • 缺陷：若将一个大的方法申明为synchronized将会影响效率的；
3. 同步块：
   • synchronized(Obj){};
   • Obj称之为同步监视器：
     • Obj可以是任何对象，，但是推荐使用共享资源（变化的量，增删改查）作为同步监视器
     • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
4. 同步监视器的执行过程：
   • 第一个线程访问，锁定同步监视器，执行其中代码；
   • 第二个线程访问，发现同步监视器被锁定，无法访问；
   • 第一个线程访问完毕，解锁同步监视器；
   • 第二个线程访问，发现同步监视器没有锁，然后锁定并访问；

6.3 死锁

1. 定义：
   • 多个各自占有一些共享资源，并且等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形；
   • 某一个同步块，同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题；
2. 死锁避免的方法：
   • 互斥条件：一个资源每次只能被一个进程使用；
   • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
   • 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
   • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源；
   • 只要破坏其中一个即可避免死锁；

6.4 Lock(锁)

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

class A{
        private final ReentrantLock lock = new ReentrantLock();
        public void m(){
                lock.lock();
                try{
                        //保证线程安全的代码;
                }finally {
                        lock.unlock();
                        //如果同步代码有异常，要将unlock()写入finally语句块
                }
        }
}

6.5 synchronized 与 Lock的对比

1. Lock是显示锁，synchronized是隐式锁，出了作用域自动释放；
2. Lock只有代码块锁，synchronized有代码块锁和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
4. 优先使用顺序：
   • Lock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法（在方法体之外）

7、线程通信

7.1 图片：

7.2 管程法

• 代码：

package com.ruixi.thread;

/**
 * @Author: ruixi
 * @Date: 2021/1/25 10:31
 */
public class TestPC {
        public static void main(String[] args) {
                SynContainer container = new SynContainer();

                new Productor(container).start();
                new Consumer(container).start();
        }
}
//生产者
class Productor extends Thread{
        SynContainer container;

        public Productor(SynContainer container){
                this.container = container;
        }

        @Override
        public void run() {
                for(int i = 0; i < 100; i++){
                        System.out.println("生产了"+i+"只鸡");
                        container.push(new Chicken(i));
                }
        }
}
//消费者
class Consumer extends Thread{
        SynContainer container;

        public Consumer(SynContainer container) {
                this.container = container;
        }
        //消费
        @Override
        public void run() {
                for(int i = 0; i < 100; i++){
                        System.out.println("消费了-->"+container.pop().id+"只鸡");
                }
        }
}
//产品
class Chicken{
        int id;//产品编号
        public Chicken(int id) {
                this.id = id;
        }
}
//缓冲区
class SynContainer{
        //需要一个容器大小
        Chicken[] chickens = new Chicken[10];
        //容器计数器
        int count = 0;
        //生产者放入产品
        public synchronized void push(Chicken chicken){
                //如果容器满了，就需要等待消费
                if(count  == chickens.length){
                        //通知消费者消费，生产等待
                        try{
                                this.wait();
                        }catch(InterruptedException e){
                                e.printStackTrace();
                        }
                }
                chickens[count] = chicken;
                count++;

                //通知消费者可以消费了
                this.notifyAll();
        }
        //消费者消费产品
        public synchronized Chicken pop(){
                //判断能否消费
                if(count == 0){
                        //等待生产者生产，消费者等待
                        try{
                                this.wait();
                        }catch(InterruptedException e){
                                e.printStackTrace();
                        }
                }
                //如果可以消费
                count--;
                Chicken chicken = chickens[count];
                //通知生产者生产
                this.notifyAll();
                return chicken;
        }
}

7.3标志位法

7.4使用线程池

1. 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大；
2. 思路：提前创建好的多个线程，放入线程池中，使用时直接获取，使用完放回池中；
3. 好处：
   • 提高响应速度（减少了创建新线程的时间）
   • 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
   • 便于线程管理：
     • corePoolSize：核心池大小
     • maximumPoolSize：最大线程数
     • keepAliveTime：线程没有任务时最多保持多长时间后会终止
4. JDK5.0提供了线程池相关API：ExecutorService和Executors:
   • ExecutorService: 真正的线程池接口。
     • void execute(Runnable command) :执行任务/命令，没有返回值，一般用来执行Runnable
     • void shutdown()：关闭连接池
   • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。