多线程基础知识，本资料主要是依据尚硅谷宋红康老师的笔记整理的，目的是方便以后自己回顾，也欢迎各位指出笔记中的错误

于 2022-01-15 20:01:43 发布
阅读量180 收藏
点赞数
分类专栏： 笔记 文章标签： java 多线程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47774447/article/details/122500495
版权

1.基本概念，程序，线程，进程

1.1程序，线程，进程

    程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
    进程：进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程，比如说我们使用的微信，qq这些都是一个进程。
    线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。一个进程里面可以有多个线程。

1.2并行和并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

1.3为什么要使用多线程

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
  2. 提高计算机系统CPU的利用率。
  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

2.线程的创建和使用

2.1继承Thread的方式

步骤：

  1. 定义子类继承Thread类。
  2. 子类中重写Thread类中的run方法。
  3. 创建Thread子类对象，即创建了线程对象。
  4. 调用线程对象start方法：启动线程，调用run方法。
package com.aiguigu.Thread;

/**
 * 1.创建一个类让他继承Thread
 * 2.在类中重写run()方法
 * 3.在主方法中创建继承类得子对象
 * 4.调用start方法
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/14 14:37
 */
class newThread extends Thread {
    @Override
    public void run() {

    }
}

public class ThreadTest {
    public static void main(String[] args) {
        newThread t1 = new newThread();
        t1.start();
    }

}

2.2线程优先级的使用方法

线程优先级的等级：如果不设置的话，默认就是第5个等级
线程优先级的等级：在这里插入图片描述
涉及的两个方法：
getPriority():返回线程的优先级。
setPriority(int newPriority):改变线程的优先级。
需要注意的两个点：
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

2.3实用Runable接口的方式创建对象

步骤：

  1. 定义子类，实现Runnable接口。
  2. 子类中重写Runnable接口中的run方法。
  3. 通过Thread类含参构造器创建线程对象。
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
  5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
package com.aiguigu.Runable;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/14 19:23
 */
class window implements Runnable {
    private int ticket = 100;

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

public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }


}

问题：存在买重复票的情况。

2.4两种实现方式的对比

区别：
继承Thread：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。
实现方式的相对来说更好：
避免了单继承的局限性（接口可以多实现）
多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

2.5实现Callable接口

与使用Runnable接口相比。Callable接口的优点：
相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
具体代码：

package com.aiguigu.collable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 18:39
 */
//1.可以有泛型的返回值
class callablee implements Callable<Integer> {
    //2.方法可以抛出异常
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        return sum;
    }
}

public class callableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        callablee c1 = new callablee();
//将callcble接口实现类的对象传递到FutureTask容器中
        FutureTask<Integer> futureTask = new FutureTask<Integer>(c1);
//创建Thread对象,并调用start方法
        new Thread(futureTask).start();
//        获取返回值的结果
        Integer sum = futureTask.get();
        System.out.println(sum);


    }
}

注意要点：1.将Callable接口的对象要传递到FutureTask构造器中，创建FutureTask的对象。
2.创建Thread对象，将FutureTask的对象作为参数传递到Thread对象的构造器中去。

2.6线程池

背景：
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
思路：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交
通工具。
好处：
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
在这里插入图片描述
具体代码实现：

package com.aiguigu.xianchengchi;

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

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 19:40
 */
class numThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}
class numThread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 100; i < 200; i++) {
            System.out.println(Thread.currentThread().getName());
            System.out.println(i);
        }
    }
}

public class xainTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor t1 = (ThreadPoolExecutor) service;
        service.execute(new numThread());
        service.execute(new numThread1());
    }
}

总结：线程的创建的方式有四种形式：1.基于继承Thread的方式创建线程
2.使用实现Runable接口的方式
3.使用实现Callable接口的方式
4.使用线程池的方式

3.线程的生命周期

Jdk中的state（）方法中的定义了线程的几种状态：、
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态：
**就绪：**处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已
具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线
程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中
止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
在这里插入图片描述
注意两个方法：yield（）：代表的是线程主动释放cpu的资源。
join（）方法在a线程中调用b.join()会导致a线程进入堵塞。

4.线程的同步

1.问题描述：卖票过程中，出现了重票和错票的情况。
2. 问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有
执行完，另一个线程参与进来执行。导致共享数据的错误。
3. 解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以
参与执行。

4.1同步代码块

synchronized（对象）{
共享的数据
}
在这里插入图片描述
使用Runnable接口实现线程安全：

package com.aiguigu.Runable;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/14 19:23
 */
class window implements Runnable {
    private int ticket = 100;
    Object obj=new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }


}

此处的obj也可以直接使用this，表示那个对象调用run方法就是那个对象，很明显此时的话，是w1调用run（）方法。

4.2同步代码块

使用Thread继承的方式：

package com.aiguigu.Thread;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/14 16:22
 * 依据Thread案例，实现三个窗口卖票
 */
class dianyin extends Thread {
    private static int ticket = 100;


    @Override
    public void run() {
        while (true) {
            try {
                show();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
    /*
     * 如果此处不加static的话，此处默认的同步监视器为this，但是在继承的方式中this指代的对象是不唯一的
     * 不符合我们监视器唯一的思想，但是加上static之后，此时所监视器指代的是类.class*/

    public static synchronized void show() throws InterruptedException {
        Thread.sleep(100);
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        dianyin t1 = new dianyin();
        dianyin t2 = new dianyin();
        dianyin t3 = new dianyin();
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();


    }
}

如果此处不加static的话，此处默认的同步监视器为this，但是在继承的方式中this指代的对象是不唯一的
不符合我们监视器唯一的思想，但是加上static之后，此时所监视器指代的是类.class

4.3锁

  1. 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  2. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
    线程的最终状态是走向死亡，而不是陷入阻塞。
    解决方法：
    1.专门的算法、原则
    2.尽量减少同步资源的定义
    3.尽量避免嵌套同步
    代码举例：
package com.aiguigu.Lock;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 12:54
 */
public class si {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        
        new Thread(){
            @Override
            public  void run() {
            //当s1休眠的时候，下面的线程已经拿到了s2的锁，导致，此线程无法走下去，因为拿不到s2这个监视器对象。
            //此时就会陷入阻塞状态，也就是我们说的死锁状态。
                synchronized (s1){
                    s1.append("a");
                    s2.append("b");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                synchronized (s2){
                    s1.append(1);
                    s2.append(2);
                }
                System.out.println(s1);
                System.out.println(s2);
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("d");
                }
                synchronized (s1){
                    s1.append(3);
                    s2.append(4);
                }
                System.out.println(s1);
                System.out.println(s2);
            }
        }).start();
    }
}

4.4线程同步-利用lock（）的方式

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
显式加锁、释放锁。
代码步骤：

package com.aiguigu.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 13:22
 */
public class jie implements Runnable {
    private int ticket = 100;
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

class Test {
    public static void main(String[] args) {
        jie w = new jie();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();


    }
}

常见的面试题：synchronized 与 Lock 的对比
相同点：都可以解决线程的安全问题
不同点：1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是
隐式锁，出了作用域自动释放
2. Lock只有代码块锁，synchronized有代码块锁和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有
更好的扩展性（提供更多的子类）

5.线程的通信

线程通信也可以理解成为几个线程之间的交互问题。
线程通信中用到的三个常用的方法：
wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当
前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有
权后才能继续执行。
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
注意事项：
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报
java.lang.IllegalMonitorStateException异常。也就是说不能使用lock的方式去使用。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，
因此这三个方法只能在Object类中声明。
案例：创建两个线程交互打印1-100.

package com.aiguigu.Runable;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/14 19:23
 */
class window implements Runnable {
    private int ticket = 100;
//    Object obj=new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (ticket > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

wait（）和sleep（）方法的异同
相同点：一旦执行方法，都可以使当前的线程进入阻塞状态。
不同点：1.两个方法声明的位置不同：Thread类中声明sleep（），而object类中声明wait（）
2.调用的要求不同：sleep（）可以再任何需要的场景下调用。wait（）必须使用在同步代码快中或同步方法中。
3.关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep（）不会释放锁，wait（）会释放锁。
生产者和消费者的经典问题：

package com.aiguigu;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 15:41
 */
/*
* 问题描述：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
果店中有产品了再通知消费者来取走产品。*/
//    存在两个线程：生产者线程和消费者线程。两个线程共有店员和产品
//    店员
class Clerk {
    private static int product = 0;

    public synchronized void createProduct() throws InterruptedException {
        if (product < 20) {
            notify();
            product++;
            System.out.println("生产者生产了第" + product + " 个产品");
        }else {
            //等待
            wait();
        }
    }

    public synchronized void consume() throws InterruptedException {
        if (product>0){
            notify();
            System.out.println("消费者消费了第" + product + " 个产品");
            product--;
        }else {
            //等待
            wait();
        }
    }
}

//生产者线程
class Product implements Runnable {
    private Clerk clerk;

    public Product(Clerk clerk) {
        this.clerk = clerk;
    }

    public Product() {
    }

    @Override
    public void run() {
        while (true) {
            try {
                clerk.createProduct();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者线程
class consume implements Runnable {
    private Clerk clerk;

    public consume(Clerk clerk) {
        this.clerk = clerk;
    }

    public consume() {
    }

    @Override
    public void run() {
        while (true) {
            try {
                clerk.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

public class ProducterTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        //共同使用clerk这个对象，作为监视器
        Thread p1 = new Thread(new Product(clerk));
        Thread c1 = new Thread(new consume(clerk));
        p1.setName("生产者");
        c1.setName("消费者");
        p1.start();
        c1.start();


    }


}

使用ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()
实现线程之间的通信：

package com.aiguigu;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 苏龙
 * @version 1.0
 * @date 2022/1/15 15:41
 */
/*
* 问题描述：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
果店中有产品了再通知消费者来取走产品。*/
//    存在两个线程：生产者线程和消费者线程。两个线程共有店员和产品店员
//线程必须共用同一把锁
class Clerk {
    private static int product = 0;
    Lock lock = new ReentrantLock();
    //    创建两个Condition对象，用于控制两个线程
    public Condition condition1 = lock.newCondition();
    public Condition condition2 = lock.newCondition();

    public void createProduct() throws InterruptedException {
        lock.lock();
        try {
            if (product < 20) {

                product++;
                System.out.println("生产者生产了第" + product + " 个产品");
                //唤醒消费者过来消费
                condition2.signal();
            } else {
                //等待
                Thread.sleep(1000);
                condition1.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() throws InterruptedException {
        lock.lock();
        try {
            if (product > 0) {
                System.out.println("消费者消费了第" + product + " 个产品");
                product--;
                //唤醒生产者继续生产
                condition1.signal();
            } else {
                //等待
                condition2.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

//生产者线程
class Product implements Runnable {
    private Clerk clerk;

    public Product(Clerk clerk) {
        this.clerk = clerk;
    }

    public Product() {
    }

    @Override
    public void run() {
        while (true) {
            try {
                clerk.createProduct();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者线程
class consume implements Runnable {
    private Clerk clerk;

    public consume(Clerk clerk) {
        this.clerk = clerk;
    }

    public consume() {
    }

    @Override
    public void run() {
        while (true) {
            try {
                clerk.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

public class ProducterTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        //共同使用clerk这个对象，作为监视器
        Thread p1 = new Thread(new Product(clerk));
        Thread c1 = new Thread(new consume(clerk));
        p1.setName("生产者");
        c1.setName("消费者");
        p1.start();
        c1.start();
    }


}
weixin_47774447
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值