JAVA多线程（基础）

程序员正正

已于 2022-04-04 11:05:03 修改

阅读量257

点赞数

分类专栏： Java基础文章标签： java 开发语言后端

于 2021-10-27 20:38:46 首次发布

本文链接：https://blog.csdn.net/WXxz0/article/details/121001409

版权

Java基础专栏收录该内容

29 篇文章 1 订阅

订阅专栏

线程相关概念

程序(program)

是为完成特定任务、用某种语言编写的-组指令的集合。
简单的说:就是我们写的代码

进程

进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为
该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分
配新的内存空间。
进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程:有它自身的
产生、存在和消亡的过程

什么是线程

线程由进程创建的，是进程的一个实体
一个进程可以拥有多个线程，如下图

请添加图片描述

其他相关概念

单线程:同一个时刻，只允许执行一个线程
多线程:同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时打
开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
并发:同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简
单的说，单核cpu实现的多任务就是并发。
并行:同一个时刻，多个任务同时执行。多核cpu可以实现并行。

线程基本使用

创建线程的两种方式

在java中线程来使用有两种方法：

继承Thread类
重写run方法
实现Runnable接口，重写run方法

请添加图片描述

继承Thread类重写run方法

package threaduse;

/**
 * @author 许正
 * @version 1.0
 * 演示通过继承Thread类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
//        cat. run();//run方法就是一一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        cat.start();

        //说明:当main线程启动一个子线程Thread-0,主线程不会阻塞，会继续执行
        System.out.println("主线程继续执行..." + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
            //为了能看到效果，也让主线程休眠1秒
            Thread.sleep(1000);
        }
    }
}

//1. 当一个类继承了Thread 类，该类就可以当做线程使用
//2. 我们会重写run方法，写上自己的业务代码
//3. run Thread类实现了Runnable 接口的run方法

class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            // 该线程每隔1秒。 在控制台输出"喵喵,我是小猫咪"
            System.out.println("喵喵,我是小猫咪" + "第" + ++times + "次输出" + "线程名：" + Thread.currentThread().getName());
            //让该线程休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80) {
                break;
            }
        }
    }
}

实现Runnable接口，重写run方法

说明:

java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承
Thread类方法来创建线程显然不可能了。
java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创
建线程

package threaduse;

/**
 * @author 许正
 * @version 1.0
 * 通过实现接口Runnable 来开发线程
 */
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //创建了Thread对象， 把dog对 象(实现Runnable) ,放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}

class Dog implements Runnable {//通过实现Runnable接口，开发线程
    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫...hi" + "第" + ++count + "次" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

继承Thread Vs实现Runnable的区别

从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本
质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了
Runnable接口
实现Runnable接口方式更加适合多个线程共享-个资源的情况，并且避免了
单继承的限制

package com.xz.ticket;

/**
 * @author 许正
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票
 */
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();


        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();

    }
}

class SellTicket01 extends Thread {
    private static int ticketNums = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                System.out.println("票卖完了，售票结束");
                break;
            }
            System.out.println("窗口：" + Thread.currentThread().getName() + "卖出了一张票，现在还剩余票数：" + (ticketNums--));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

class SellTicket02 implements Runnable {

    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                System.out.println("票卖完了，售票结束");
                break;
            }
            System.out.println("窗口：" + Thread.currentThread().getName() + "卖出了一张票，现在还剩余票数：" + (ticketNums--));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

线程终止

基本说明

当线程完成任务后，会自动退出。
还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

package com.xz.exit_;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadExist {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();

        Thread.sleep(10 * 1000);
        t.setBool(false);
    }
}

class T extends Thread {
    private boolean bool = true;
    private int count = 0;

    public boolean isBool() {
        return bool;
    }

    public void setBool(boolean bool) {
        this.bool = bool;
    }


    @Override
    public void run() {
        while (bool) {
            System.out.println("T进程正在执行" + (++count));
            try {
                sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程常用方法

常用方法

常用方法第一组

setName //设置线程名称，使之与参数name 相同
getName //返回该线程的名称
start //使该线程开始执行; Java 虚拟机底层调用该线程的start0方法
run //调用线程对象run方法;
setPriority //更改线程的优先级
getPriority //获取线程的优先级
sleep //在指定的毫秒数内让当前正在执行的线程休眠 (暂停执行)
interrupt //中断线程

package com.xz.method;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关方法
        T t = new T();
        t.setName("猪皮");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();

        //主线程打印5次 hi,然后中断子线程的休眠
        for (int i = 1; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
        }
        System.out.println(t.getName() + "的优先级：" + t.getPriority());

        t.interrupt();

    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "  吃包子~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "  休眠中...");
                sleep(20 * 1000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                // InterruptedException是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被打断...");
            }
        }

    }
}

常用方法第二组

yield:线程的礼让。让出cpu,让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
案例:创建一个子线程,每隔1s输出hello,输出20次，主线程每隔1秒，输出hi ,输出20次.要求:两个线
程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，

请添加图片描述

package com.xz.method;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程正在运行..." + "  第" + (i + 1) + "次");
            Thread.sleep(50);

            if (i == 4) {
                System.out.println("主程序执行了5次，让子程序先执行完毕：");
//                t2.join();
                Thread.yield();//礼让，不一定成功，只有在资源短缺情况下才成功
                System.out.println("子程序执行完毕... 主程序继续执行...");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {

        for (int i = 0; i < 20; i++) {
            System.out.println("子线程正在运行..." + "  第" + (i + 1) + "次");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

注意事项和细节

start底层会创建新的线程，调用run, run 就是一个简单的方法调用，不会启动新线程
线程优先级的范围
interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
sleep:线程的静态方法，使当前线程休眠

Exercise

package com.xz.method;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Hello hello = new Hello();
        Thread thread = new Thread(hello);

        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            Thread.sleep(1000);
            if (i==5){
                thread.start();
                thread.join();
            }
        }
        System.out.println("主线程结束...");
    }
}

class Hello implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("hello " + i);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程结束...");
    }
}

用户线程和守护线程

用户线程:也叫工作线程，当线程的任务执行完或通知方式结束
守护线程: - -般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束!
常见的守护线程:垃圾回收机制

package com.xz.method;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        //如果我们希望当main线程结束后，子线程自动结束
        //只需将子线程设为守护线程即可
        t3.setDaemon(true);
        t3.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(100);
        }
    }
}

class T3 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("马蓉和宋喆在欢乐的聊天...");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态

请添加图片描述

线程状态转换图

请添加图片描述

写程序查看线程状态

package com.xz.state_;

/**
 * @author 许正
 * @version 1.0
 */
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(50);
        }

        System.out.println("=============");
        System.out.println(t.getName() + " 状态 " + t.getState());
    }
}

class T extends Thread {
    @Override
    public void run() {

        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

Synchronized

线程同步机制

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

同步具体方法-Synchronizede

同步代码块

 synchronized (对象) { // 得到对象的锁，才能操作同步代码
   	//需要被同步代码;
 }

synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m (String name){
	//需要被同步的代码
}

演示

package com.xz.synchronized_;

/**
 * @author 许正
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票
 */
public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();


//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();


        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
    }
}


class SellTicket03 implements Runnable {

    private int ticketNums = 100;

    public boolean isBool() {
        return bool;
    }

    public void setBool(boolean bool) {
        this.bool = bool;
    }

    private boolean bool = true;

    public synchronized void sell() {
        if (ticketNums <= 0) {
            System.out.println("票卖完了，售票结束");
            setBool(false);
            return;
        }
        System.out.println("窗口：" + Thread.currentThread().getName() + "卖出了一张票，现在还剩余票数：" + (ticketNums--));
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (bool) {
            sell();
        }


    }
}

class SellTicket01 extends Thread {
    private static int ticketNums = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                System.out.println("票卖完了，售票结束");
                break;
            }
            System.out.println("窗口：" + Thread.currentThread().getName() + "卖出了一张票，现在还剩余票数：" + (ticketNums--));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

class SellTicket02 implements Runnable {

    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                System.out.println("票卖完了，售票结束");
                break;
            }
            System.out.println("窗口：" + Thread.currentThread().getName() + "卖出了一张票，现在还剩余票数：" + (ticketNums--));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

同步原理分析

请添加图片描述

互斥锁

基本介绍

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

注意事项和细节

同步方法如果没有使用static修饰:默认锁对象为this
如果方法使用static修饰，默认锁对象:当前类.class
实现的落地步骤:

需要先分析上锁的代码
选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可!

//1. public synchronized static void m1() {}锁是加在SellTicket03. class
//2.如果在静态方法中，实现一个同步代码块。
public synchronized static void m1() {
}

//静态方法中不能直接使用this
public static void m2() {
    synchronized (SellTicket03.class) {
        System.out.println("m2");
    }
}

线程的死锁

基本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避
免死锁的发生.

应用案例

妈妈:你先完成作业，才让你玩手机
小明:你先让我玩手机，我才完成作业。

模拟

package com.xz.synchronized_;

/**
 * @author 许正
 * @version 1.0
 * 模拟线程死锁
 */
public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");

        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析：
        //1. 如果flag为 T ，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
        //2.如果线程A得不到o2对象锁，就会Blocked
        //3.如果flag为F,线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁
        //4.如果线程B得不到o1对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) {//这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) {//这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

释放锁

下面操作会释放锁

当前线程的同步方法、同步代码块执行结束
案例: 上厕所，完事出来
当前线程在同步代码块、同步方法中遇到break、 return.
案例:没有正常的完事，经理叫他修改bug,不得已出来
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
案例:没有正常的完事，发现忘带纸，不得已出来
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

案例:没有正常完事，觉得需要酝酿下，所以出来等会再进去

下面操作不会释放锁

线程执行同步代码块或同步方法时，程序调用Thread.sleep(、 Thread.yield(方
法暂停当前线程的执行，不会释放锁
案例:上厕所，太困了，在坑位上眯了一会
线程执行同步代码块时，其他线程调用了该线程的suspend(方法将该线程挂起，
该线程不会释放锁。
提示:应尽量避免使用suspend(和resume()来控制线程，方法不再推荐使用

程序员正正

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA多线程（基础）

线程相关概念程序(program)是为完成特定任务、用某种语言编写的-组指令的集合。简单的说:就是我们写的代码进程进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程什么是线程线程由进程创建的，是进程的一个实体一个进程可以拥有多个线程，如下图其他相关概念单线程:同一个
复制链接

扫一扫