从零学Java 多线程(基础)

发布时间:2024年01月15日

Java 多线程(基础)

1 多线程

1.1 多任务

在这里插入图片描述

  • 现实生活中太多这样同时做多件事的例子了,看起来是多个任务同时都在做,其实本质上我们的大脑在同一时间依旧只能做一件事

1.2 多线程

在这里插入图片描述

  • 原来是一条路,慢慢地因为车变多了,造成了道路堵塞,使通行效率变低。
    为了提高使用的效率,能够充分利用道路,于是加了多个车道,从此,妈妈再也不用担心道路堵塞了

1.3 普通方法调用和多线程

在这里插入图片描述

2 进程和线程

2.1 什么是进程(Process)?

进: 正在进行; 程: 程序

程序:程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念;

进程:进程是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位

  • 程序是静止的,只有真正运行时的程序,才被称为进程。

  • 目前操作系统都是支持多进程,可以同时执行多个进程,通过进程ID区分。

2.2 什么是线程(Thread)?

概念: 线程,又称轻量级进程(Light Weight Process)。

  • 进程中的一个执行路径,同时也是CPU的基本调度单位。
  • 进程由多个线程组成,彼此间完成不同的工作,抢占式执行,称为多线程。
  • 当然一个进程中至少有一个线程,不然没有存在的意义

注意:很多多线程都是模拟出来的,真正的多线程是指有多个CUP,即多核,如服务器。如果是模拟出来的多线程,即在一个CPU的情况下,在同一时间点,CPU只能执行一个代码,只是因为切换的太快,所以便产生了同时执行的错觉;

2.3 进程和线程的区别

  • 进程是操作系统资源分配的基本单位,而线程是CPU的基本调度单位。
  • 一个程序运行后至少有一个进程。
  • 一个进程可以包含多个线程,但是至少需要有一个线程。
  • 进程间不能共享数据段地址,但同进程的线程之间可以。

3 线程的实现

3.1 线程的组成

任何一个线程都具有基本的组成部分

  • CPU时间片:操作系统(OS)会为每个线程分配执行时间。
  • 运行内存:
    • 堆内存:存储线程需使用的对象,多个线程可以共享堆中的对象。
    • 栈内存:存储线程需使用的局部变量,每个线程都拥有独立的栈。
  • 线程的逻辑代码

3.2 线程执行特点

  • 线程抢占式执行,结果随机性。
    • 效率高
    • 可防止单一线程长时间独占CPU
  • 在单核CPU中,宏观上同时执行,微观上顺序执行;多核CPU中,可以真正并发执行。

注意:线程调用不一定立即执行,由CPU调度执行

3.3 线程的创建

运行程序时, JVM会自动创建主线程(main), main线程执行main方法

3.3.1 继承Thread类
  • 继承Thread类,重写run()方法,调用start() 方法
  • 适合没有资源共享

MyThread01:

public class MyThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程...."+i);
        }
    }
}

Test:

public class Test {
    public static void main(String[] args) {
        //创建子线程
        MyThread01 thread01 = new MyThread01();
        //启动子线程
        thread01.start();
        //thread01.run();调用方法
        //main线程执行for
        for (int i = 0; i < 100; i++) {
            System.out.println("main线程......"+i);
        }
    }
}

面试题: 一个线程能启动两次吗?

答: 不能, 启动多次会出现IllegalThreadStateException错误

获取线程ID和名称

方式 1 :

//方式1 this.getName() this.getId()
System.out.println(this.getName()+"  "+this.getId()+"子线程...."+i);

方式 2 :

//方式2 Thread.currentThread().getName()/getId()
System.out.println(
    Thread.currentThread().getName()+"..."
    +Thread.currentThread().getId()+"子线程...."+i
);

修改线程名称

方式 1 :

//方式1 thread.setName()
thread01.setName("线程-01");
thread02.setName("线程-02");

方式 2 :

//方式2 构造方法
//重写构造方法
public MyThread01(String name) {
    super(name);
}

//创建子线程时,修改
MyThread01 thread01 = new MyThread01("线程-01");
MyThread01 thread02 = new MyThread01("线程-02");

课堂案例

实现4个窗口各卖100张票?

内存分析:

在这里插入图片描述

SaleTicket:

package StageOne.day19.MyThread;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: TODO
 * @date 2024/1/12 15:22
 */
public class SaleTicket extends Thread{
    //总票数
    private int count = 100;
    //重写构造方法
    public SaleTicket(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (count > 0) {
            System.out.println(Thread.currentThread().getName() +
                    "卖了第" + count + "张票");
            count--;
        }
    }
}

Test:

public class Test2 {
    public static void main(String[] args) {
        SaleTicket s1 = new SaleTicket("窗口1");
        SaleTicket s2 = new SaleTicket("窗口2");
        SaleTicket s3 = new SaleTicket("窗口3");
        SaleTicket s4 = new SaleTicket("窗口4");
        s1.start();
        s2.start();
        s3.start();
        s4.start();
    }
}
3.3.2 实现Runnable接口

实现Runnable接口

  • 适合有资源共享
  • 操作相同,共享资源类实现Runnable接口
  • 操作不同,操作类分开实现Runnable接口,构造方法传递共享资源

MyRunnable:

package StageOne.day19.MyRunnable;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: TODO
 * @date 2024/1/12 16:02
 */
public class MyRunnable implements Runnable{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(
                    Thread.currentThread().getName()+"子线程"+"..."+i
            );
        }
    }
}

Test:

public class Test {
    public static void main(String[] args) {
        //创建可运行对象
        MyRunnable runnable = new MyRunnable();
        //创建线程对象
        Thread t1 = new Thread(runnable,"线程-01");
        Thread t2 = new Thread(runnable,"线程-02");
        Thread t3 = new Thread(runnable,"线程-03");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        //main
        for (int i = 0; i < 100; i++) {
            System.out.println(
                    "主线程..............."+i
            );
        }
    }
}

课堂案例 1

实现4个窗口共卖100张票?

内存分析:

Ticket:

public class Ticket implements Runnable{
    private int count = 100;
    @Override
    public void run() {
        while (count > 0) {
            System.out.println(Thread.currentThread().getName() +
                    "卖了第" + count + "张票");
            count--;
        }
    }
}

Test:

public class Test01 {
    public static void main(String[] args) {
        //创建票对象(可运行对象)
        Ticket ticket = new Ticket();
        //创建线程对象
        Thread t1 = new Thread(ticket,"窗口1");
        Thread t2 = new Thread(ticket,"窗口2");
        Thread t3 = new Thread(ticket,"窗口3");
        Thread t4 = new Thread(ticket,"窗口4");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

课堂案例 2

你和你女朋友共用一张银行卡,你向卡中存钱,你女朋友从卡中取钱,使用程序模拟过程?

BankCard:

public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

Save:

public class Save implements Runnable{
    private BankCard card;

    public Save(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            card.setMoney(card.getMoney()+1000);
            System.out.println(Thread.currentThread().getName()+"第"+i+"次存钱存了1000元," +
                    " 当前余额为" + card.getMoney());
        }
    }
}

Withdraw:

public class Withdraw implements Runnable{
    private BankCard card;

    public Withdraw(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (card.getMoney()>=1000) {
                card.setMoney(card.getMoney()-1000);
                System.out.println(Thread.currentThread().getName()+"取走了1000元"
                +"当前余额为"+card.getMoney());
            } else {
                System.out.println("当前余额不足...");
                i--;//取款失败不计数,保证把钱取完
            }
        }
    }
}

Test:

public class Test {
    public static void main(String[] args) {
        //卡
        BankCard card = new BankCard();
        //存钱
        Save save = new Save(card);
        //取钱
        Withdraw withdraw = new Withdraw(card);
        //线程
        Thread t1 = new Thread(save,"小明");
        Thread t2 = new Thread(withdraw,"小红");
        t1.start();
        t2.start();
    }
}
文章来源:https://blog.csdn.net/weixin_50858647/article/details/135592998
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。