Java线程基础

默默无闻的IT民工

于 2022-11-22 15:07:39 发布

阅读量441

点赞数

分类专栏： Java基础文章标签： java 开发语言 intellij-idea

本文链接：https://blog.csdn.net/m0_51972565/article/details/127982751

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java线程基础

线程相关的概念

进程： 程序的一次执行过程，或是正在运行的一个程序为一个进程。是动态过程，因为它具备产生，存在，消亡的过程。

线程： 线程是由进程创建的，是进程的一个实体，一个进程可以有多个线程。例如：打开迅雷就是启动一个进程，迅雷开启一个文件下载任务就是开启一个线程。

单线程：同一个时刻，只允许执行一个线程
多线程：同一个时刻, 可以执行多个线程：例如QQ多个聊天窗口，迅雷多个文件下载

并发和并行

并发：

同一时间，多个任务交替执行，但具体的某一个时刻是只执行一个任务，造成一种“貌似同时”的错觉。简单来说：单核CPU要实现多个任务就是并发。

一个CPU在人类察觉不到时间粒度的情况下去来回切换这两个进程的执行。现实生活中例如：开车打电话，人不可能做到一个大脑在同一个时刻同时思考开车和接电话，而是因为大佬思考切换的速度我们意识不到，才看出来我们貌似是在”同时“。这种情况也叫：“宏观上并行，微观上并发”。

并行：

同一时刻，多个任务同时执行。

所谓并行，好比两人同时在两条线上向前移动，而不是一个人在两条线之前来回切换向前移动。简单说：就是多核CPU同时在执行进程。如果两个CPU分别在执行一个进程，那么就是并行执行。但是，一台多核电脑，也可以同时存在并发和并行，因为如果进程太多，单个CPU执行多进程的同时也和其他CPU并行执行。

线程基本使用

线程的创建：
IDEA类图

在创建线程前，必须明白一点，运行main函数，就是开启一个进程。而随之会开启一个线程（main线程），而所写的方法就运行在线程上，方法可以在main线程中执行。也可以开启子线程，子线程也可以继续开启新的线程，并在其中执行其他方法。但是当进程开启后（main函数运行后），只有所有的线程（包括各类子线程等）运行结束之后，进程才会关闭。不要产生在只有当主线程（main）结束，进程就结束的想法。

方式一：继承Thread类

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        //使用继承Thread的方式 创建线程 运行时：使用start()方法
        cat.start();
        System.out.println("主线程执行 线程名："+Thread.currentThread().getName());
    }
}
/**
 * 创建线程的第一种方式：
 * 继承Thread类
 */
class Cat extends Thread{
    int time = 0;
    // 重写父类（Thread）的run方法 该方法是开启线程后执行的内容
    @Override
    public void run() {
        //该线程执行打印8次结束
        while (time != 8){
            System.out.println("喵喵~~~~"+(++time)+" 当前线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程执行结束");
    }
}

在这里插入图片描述

注意： 这里并不能直接调用重写Thread的run()方法。为什么？因为我们是在主线程当中调用重写的run()方法，因此没有新开辟线程让其运行，而是直接在主线程运行，代码向下顺序执行。
在这里插入图片描述

而start()方法，其本质是调用了本地的方法（Native method）start0()，它向 JVM 提交开启线程的申请，JVM向计算机系统请求分配资源开启线程并最终调用run()方法实现子线程中运行。

如果主线程（main）当中也有循环操作，可以在控制台中看到两个线程的打印结果是交错的，这就是多线程的并发。

方式二：实现Runable接口

java是单继承特性，某些情况下该类继承了其他类，此时如果创建线程就必须使用实现接口的方式。

public class Thread02 {
    public static void main(String[] args) {
        //实现接口创建的线程 启动方式
        Dog dog = new Dog();
        /**
        使用了设计模式中的 静态代理模式（需要了解）
        */
        Thread thread = new Thread(dog);
        //子线程任务
        thread.start();
        //主线程任务
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程：" + (i+1) +"===" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("主线程结束");

    }
}

/**
 * 线程创建方式二：实现 Runnable 接口
 */
class Dog implements Runnable{
    int times = 0;
    @Override
    public void run() {
        while (times != 10){
            System.out.println("旺旺~~~~" + (++times) + "线程名：" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程结束");
    }
}

建议使用实现接口的方式创建线程。

经典售票问题

多线程卖票出现超卖问题：

/**
 * 多线程售票问题:
 * 开辟三个线程同时售票（并发） 会出现超卖问题
 */
public class SellTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }
}
class Ticket implements Runnable{

    //由于实现接口方式创建的线程其启用多个线程是共享资源的，不需要total为静态变量
    private int total = 100;

    @Override
    public void run() {
        while(true){
            if (total <=0 ){
                System.out.println("窗口："+Thread.currentThread().getName()+"售票结束===剩余："+total);
                break;
            }
            //线程休眠50ms模拟操作的时间
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //模拟卖票
            System.out.println("窗口："+Thread.currentThread().getName()+"卖出一张票=====剩余："+(--total));
        }
    }
}

问题：
在这里插入图片描述

为什么会出现剩余票数不同步和超卖问题呢？

原因：因为多线程会导致三个线程出现同时读取票数进行操作的情况，于是可能出现 Thread0读取票数准备减去票数前被Thread1读取该票数并操作，那么读取的是同一个票数，并且都卖出去了一张，如果此时只剩1张票，被三个线程都读取：一个线程卖完为0，而其它两个先后由于读取时候为1，通过了售票条件，在操作时都减一，就会出现多卖2张，结果-2。

如何解决? 上锁

线程结束

线程如何结束？在开启线程执行任务时，会在run()方法中开启while循环，将循环条件设置为boolean值，并生成set方法，即可在外部通过set该条件值控制线程结束。

public class ThreadEnd {
    public static void main(String[] args) {
        Task task = new Task();
        new Thread(task).start();
        //主线程休眠6s后结束子线程
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //结束线程中的循环体
        task.setStarted(false);
    }
}
class Task implements Runnable{
    private int count = 0;
    private boolean started = true;
    @Override
    public void run() {
        while(started){
            System.out.println("任务执行："+(++count));
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程已结束");
    }
    public void setStarted(boolean started) {
        this.started = started;
    }
}

线程中断

什么是中断？中断不是指线程结束，而是中断异常。例如在线程休眠过程中触发中断，就会进入中断异常。一般用于：中断正在休眠的进程。

public class ThreadInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Task01 task01 = new Task01();
        Thread thread = new Thread(task01);
        thread.start();
        //5s后中断线程
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("子线程休息："+(i+1)+"s");
        }
        //中断子线程休眠 继续执行任务
        thread.interrupt();
    }
}
class Task01 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true){
            System.out.println("任务执行："+(++count));
            //线程准备休眠10s
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                System.out.println("子线程"+Thread.currentThread().getName()+"被中断了");
            }
        }
    }
}

线程插队

yield()

该方法称为线程礼让。即让出占用的CPU资源，让其他线程执行。但是，礼让的时间不确定，也不一定能礼让成功。如果CPU资源紧张，那么大概率成功，如果CPU完全充足，那么CPU也不会使其礼让成功。

在这里插入图片描述

例如：CPU并发执行两个线程，如果Thread0调用yield() ，可能CPU会优先执行Thread 1。

join()

如图：join方法插队，Thread 0 中执行 t1.join() 意味着在 Thread 0 线程执行到该方法时插入 Thread 1，当Thread 1执行完结束之后才能执行 Thread 0。

例如主线程中执行子线程 join()，只有当子线程结束后，主线程才能继续执行。

public class ThreadJoin {
    public static void main(String[] args) {
        Task02 task02 = new Task02();
        Thread thread = new Thread(task02);
        thread.start();
        for (int i = 0; i < 20; i++) {
            if (i == 5){
                try {
                    //线程插队
                    //thread.join();
                    //线程礼让
                    Thread.yield();//main礼让子线程 cpu资源充分的情况下一般失效
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"执行："+(i+1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Task02 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while(count != 20){
            System.out.println(Thread.currentThread().getName()+"执行："+(++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程结束");
    }
}

守护线程

守护线程：为工作线程服务的线程，当所有的用户线程结束，守护线程自动结束。利用守护线程可以去实现监视其它用户线程等功能

经典的守护线程：垃圾回收机制

守护线程必须在start()之前设置Daemon

示例：

		Task03 task03 = new Task03();
        Thread thread = new Thread(task03);
        thread.setDaemon(true); //设置为守护线程
        thread.start();

线程生命周期

图为重点

在这里插入图片描述

Synchronized

线程同步机制

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在同一时刻，最多有一个线程访问，以保证数据的完整性。
也可以这里理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

同步方法

同步具体方法-Synchronized
1.同步代码块
synchronized(对象){//得到对象的锁，才能操作同步代码
	//需要被同步代码
}
2.synchronized还可以放在方法声明中，表示整个方法-为同步方法
public synchronized void m(String name){
	//需要被同步的代码
}

互斥锁

1.Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性，
2.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
4.同步的局限性：导致程序的执行效率要降低（因为原本多线程却由于同步上锁导致执行受到阻塞）
5.同步方法（非静态的）的锁可以是this,也可以是其他对象（要求是同一个对象）
6.同步方法(静态的)的锁为当前类本身。

利用互斥锁同步方法解决售票问题

在需要同步的方法上加锁：private synchronized void sell(),此时锁仍然在this对象上，也就是Tikek02的实例化对象上

我们使用实现接口的方式创建的线程，是通过一个实例化对象来创建多线程，共享的是同一资源。因此在方法上加锁是可行的。因为是同一实例对象的方法。
**在需要同步的代码块上加锁：**代码块上加锁实现线程同步注意这里锁对象仍然是this 而三个线程都是该同一个对象锁因此同步有效

方法同步资源开销比代码块大，因此优先考虑代码块加锁

**注意：**要实现上锁同步，必须确保锁在同一个对象，可以是this，也可以是其他对象，但必须多线程在同一个对象锁。例如：在方式二中声明一个object对象，把代码块锁的this对象换成object，也同样有效，因为三个线程都共用一个对象锁。

例如：使用继承类方式创建线程，既不能在方法上加锁，也不能代码块加锁传入this对象，而可以创建static类型的object对象从而锁加在同一个对象上。

/**
 * 使用继承的方式创建多线线程 尝试解决售票问题 注意事项：
 * 1. 继承的方式每个线程实例化对象不一样，那么不能在方法上
 */
class Ticket03 extends Thread {
    private static int total = 200;
    private  static  Object object = new Object();
    private boolean loop = true;
    private synchronized void sell(){ //给方法上锁 也不会同步 方法上锁是给this对象上锁，而在继承Thread类创建线程时，每次的实例对象(this)不一样
        if (total <= 0) {
            System.out.println("窗口：" + Thread.currentThread().getName() + "售票结束===剩余：" + total);
            loop = false;
            return;
        }
        //模拟卖票
        System.out.println("窗口：" + Thread.currentThread().getName() + "卖出一张票=====剩余：" + (--total));
        //线程休眠50ms模拟操作的时间
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (true /*loop*/) {
           synchronized (object){ //代码块加锁，共享object对象上锁是可以同步的，而this不行
               if (total <= 0) {
                   System.out.println("窗口：" + Thread.currentThread().getName() + "售票结束===剩余：" + total);
                   break;
               }
               //模拟卖票
               System.out.println("窗口：" + Thread.currentThread().getName() + "卖出一张票=====剩余：" + (--total));
               //线程休眠10ms模拟操作的时间
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            //sell();
        }

    }

}

如果在静态方法上加锁，锁加在类的本身而不是this对象：因为static会在对象初始化之前就加载，因此静态方法中是找不到this对象的。因此是可以在静态方法上加锁也可以在代码块中加锁，但是必须是类本身。
```
public synchronized static void m1(){...}//锁在 xxx.class

public static void m2(){
    ...
	synchronized(xxx.class){ //必须是类本身
       ...
    }  
}
```

//方式一：
class Ticket02 implements Runnable {
    //由于实现接口方式创建的线程其启用多个线程是共享资源的，不需要total为静态变量
    private int total = 100;
    private synchronized void sell() { //加锁 实现线程同步 （方法上加锁）
        if (total <= 0) {
            System.out.println("窗口：" + Thread.currentThread().getName() + "售票结束===剩余：" + total);
            return;
        }
        //线程休眠50ms模拟操作的时间
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //模拟卖票
        System.out.println("窗口：" + Thread.currentThread().getName() + "卖出一张票=====剩余：" + (--total));
    }

    @Override
    public void run() {
        while(total != 0){
            sell();
        }
    }
}

//方式二：
class Ticket02 implements Runnable {
    //由于实现接口方式创建的线程其启用多个线程是共享资源的，不需要total为静态变量
    private int total = 100;
    private void sell() { 
        synchronized (this){ //代码块上加锁 实现线程同步 注意这里锁对象仍然是this 而三个线程都是该同一个对象锁 因此有效
            //模拟卖票
            System.out.println("窗口：" + Thread.currentThread().getName() + "卖出一张票=====剩余：" + (--total));
        }
        //线程休眠50ms模拟操作的时间
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
	
    @Override
    public void run() {
        while(total != 0){
            sell();
        }
        System.out.println(Thread.currentThread().getName()+"售票结束! 剩余："+total);
    }
}

死锁

概念：多个线程都占用对方锁资源，但是都不肯释放，导致死锁。例如：A对B说：你把货先给我，我在给钱。B对A说：你先把钱给我，我再给你货。

模拟死锁

/**
 * 模拟死锁的发生
 */
public class DeadLock {
    public static void main(String[] args) {
        Exam exam1 = new Exam(true);
        exam1.setName("A线程");
        exam1.start();

        Exam exam2 = new Exam(false);
        exam2.setName("B线程");
        exam2.start();
    }
}
//测试死锁类
class Exam extends Thread{
    //创建两个锁对象，为了加锁同步
    static Object o1 = new Object();
    static Object o2 = new Object();
    //由flag控制对应的线程执行对应的代码
    boolean flag = true;
    //构造函数传入flag
    public Exam(boolean flag){
        this.flag = flag;
    }
    @Override
    public void run() {
        /**
         * 代码逻辑分析：
         * 1.如果flag为true,A线程先占用o1锁,执行任务，再占用o2锁,才能继续执行下去
         * 2.如果flag为false,B线程先占用哦o2锁，执行任务，再占用o1锁，才能继续执行下去
         * 3.如果AB都执行，会使得A占用了o1锁但是无法获取o2锁而释放不了o1;而B占用了o2锁但是无法获取o1锁而释放不了o2 造成死锁
         */
        if (flag){
            synchronized (o1){
                System.out.println("A占用O1锁中~");
                synchronized (o2){
                    System.out.println("A占用O2锁中~");
                }
            }
        }else{
            synchronized (o2){
                System.out.println("B占用O2锁中~");
                synchronized (o1){
                    System.out.println("B占用O1锁中~");
                }
            }
        }
    }
}

释放锁

下面操作会释放锁

当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break、return。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

下面操作不会释放锁

线程执行同步代码块或同步方法时，程序调Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。
线程执行同步代码块时，其他线程调用了该线程的suspend0方法将该线程挂起，该线程不会释放锁。
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

练习

两用户取钱，线程同步问题

/**
 * 两个用户分别从同一个卡上取钱（10000）
 * 每次都取1000，不能出现超取。
 */
public class Test01 {
    public static void main(String[] args) {
        TakeMoney takeMoney = new TakeMoney();
        new Thread(takeMoney, "用户A").start();
        new Thread(takeMoney, "用户B").start();
    }
}

class TakeMoney implements Runnable {
    private int total = 10000;
    @Override
    public void run() {
        while (true) {
            synchronized (this) { //给对象上锁 该锁为非公平锁（获得锁并操作完之后释放后继续参与锁的获取，所以非公平）
                if (total <= 0) {
                    System.out.println("ATM余额：" + total);
                    return;
                }
                //取钱
                total -= 1000;
                System.out.println(Thread.currentThread().getName() + "取：1000，ATM剩余：" + total);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

两线程执行，一个线程通知另外一个停止

/**
 * （1）在main方法中启动两个线程
 * （2）在一个线程循环随机打印100以内的整数
 * （3）直到第二个线程从键盘读取了"Q"命令后两个线程结束
 */
public class Test02 {
    public static void main(String[] args) {
        Work01 work01 = new Work01();
        Thread thread1 = new Thread(work01, "线程1");
        thread1.start();

        Work02 work02 = new Work02(work01);
        Thread thread2 = new Thread(work02, "线程2");
        thread2.setDaemon(true);//这里只有两个子线程 可以开启守护线程，如果多个线程执行，要考虑自身线程如何结束的条件。
        thread2.start();
    }

}

class Work01 implements Runnable {
    int count = 0;
    private boolean started = true;

    public void setStarted(boolean started) {
        this.started = started;
    }

    @Override
    public void run() {
        while (started) {
            int number = (int) (Math.random() * 100);//100以内
            System.out.println(Thread.currentThread().getName() + ":输出：" + number + " 次数：" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程1：任务停止");
    }
}

class Work02 implements Runnable {
    private Work01 work01;

    public Work02(Work01 work01) {
        this.work01 = work01;
    }

    @Override
    public void run() {
        //接收输入键盘命令 Q
        while (true) {
            System.out.println(Thread.currentThread().getName() + "等待接收命令(Q)");
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String cmd = scanner.next();
                if (cmd.equalsIgnoreCase("q")) {
                    work01.setStarted(false);
                } else {
                    break;
                }
            }

        }
    }
}