Java多线程

最新推荐文章于 2024-11-15 18:38:47 发布

shadow_maples

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量142

点赞数 1

分类专栏： Java基础文章标签： java hibernate

本文链接：https://blog.csdn.net/weixin_50342605/article/details/120149340

版权

Java基础专栏收录该内容

29 篇文章 0 订阅

订阅专栏

本文详细介绍了多线程概念，包括线程定义、创建方式（Thread类和Runnable接口）、状态与生命周期、线程调度、同步与死锁。通过实例演示了如何创建线程，以及如何处理线程安全问题，如银行存款取款场景中的同步操作。

摘要由CSDN通过智能技术生成

主要内容

什么是多线程
线程的创建
线程的状态和生命周期
线程调度
同步和死锁

什么是线程

进程的概念：进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程

线程是比进程还要小的运行单位，一个进程包含多个线程

线程可以看做一个子程序

时间片的轮转：是通过对CPU时间的轮转来达到多个程序同时运行的效果每个时间片很短，所以我们感受不出来

线程的创建

有两种创建方式：

创建一个Thread类，或者一个Thread子类的对象
创建一个实现Runnable接口的类的对象

Thread类

是一个线程类

[]

run方法是Thread类中十分重要的方法，可以说是线程中最重要的方法，所有线程相关的代码都是写在run方法当中的，不同功能的线程之间的区别就在于run方法中的代码不同

Runnable接口

只有一个方法run();
Runnable是Java中用于实现线程的接口
任何实现线程功能的类都必须实现该接口

通过Thread类创建线程

线程的创建和启动过程

package com.imooc.thread;

public class MyThread extends Thread {
    public void run(){
        System.out.println(getName()+"该线程正在执行！");
    }
}

package com.imooc.thread;

public class TheadTest {
    public static void main(String[] args) {
        //System.out.println("主线程1");
        MyThread mt = new MyThread();
        mt.start();//启动线程（注意此处并不是run方法）
        //一个线程只能启动一次
        //System.out.println("主线程2");
        //主线程和自定义线程执行顺序是随机的

    }
}

由下面代码运行结果得知线程运行其实是随机的

package com.imooc.thread1;

public class MyThread extends Thread {
    public MyThread(String name){
        super(name);
    }
    public void run(){
        for (int i=1;i<=10;i++){
            System.out.println(getName()+"正在运行"+i);
        }
    }

}

package com.imooc.thread1;

public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程1");
        MyThread mt2 = new MyThread("线程2");
        mt1.start();
        mt2.start();
    }
}

线程1正在运行1
线程2正在运行1
线程1正在运行2
线程2正在运行2
线程1正在运行3
线程2正在运行3
线程1正在运行4
线程2正在运行4
线程1正在运行5
线程2正在运行5
线程1正在运行6
线程2正在运行6
线程2正在运行7
线程2正在运行8
线程1正在运行7
线程1正在运行8
线程2正在运行9
线程1正在运行9
线程2正在运行10
线程1正在运行10

实现Runnable接口创建线程

为什么要实现Runable接口？

Java不支持多继承（接口可以多继承）
不打算重写Thread类的其他方法

package com.imooc.runable;

public class PrintRunnable implements Runnable {
    @Override
    public void run() {
        int i=1;
        while (i<=10)
            //因为是在接口中，Thread类的一个静态方法currentThread()（当前线程）
            System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));

    }
}

package com.imooc.runable;

public class Test {
    public static void main(String[] args) {
        PrintRunnable pr = new PrintRunnable();
        //创建线程类对象
        Thread t1 = new Thread(pr);
        t1.start();
        PrintRunnable pr2 = new PrintRunnable();
        //创建线程类对象
        Thread t2 = new Thread(pr2);
        t2.start();
    }
}

Thread-0正在运行1
Thread-1正在运行1
Thread-1正在运行2
Thread-0正在运行2
Thread-1正在运行3
Thread-1正在运行4
Thread-0正在运行3
Thread-1正在运行5
Thread-0正在运行4
Thread-1正在运行6
Thread-0正在运行5
Thread-0正在运行6
Thread-1正在运行7
Thread-0正在运行7
Thread-1正在运行8
Thread-0正在运行8
Thread-0正在运行9
Thread-0正在运行10
Thread-1正在运行9
Thread-1正在运行10

运行结果是随机的

run方法中的代码可以被多个线程共享，适合于多个线程处理同一资源的情况。将上述代码两处稍作修改：

package com.imooc.runable;

public class PrintRunnable implements Runnable {
    int i=1;//i是一个成员变量
    @Override
    public void run() {

        while (i<=10)
            //因为是在接口中，Thread类的一个静态方法currentThread()（当前线程）
            System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));

    }
}

package com.imooc.runable;

public class Test {
    public static void main(String[] args) {
        PrintRunnable pr = new PrintRunnable();
        //创建线程类对象
        Thread t1 = new Thread(pr);
        t1.start();
//        PrintRunnable pr2 = new PrintRunnable();
        //创建线程类对象
        Thread t2 = new Thread(pr);
        t2.start();
    }
}

Thread-0正在运行1
Thread-1正在运行2
Thread-1正在运行4
Thread-1正在运行5
Thread-1正在运行6
Thread-1正在运行7
Thread-1正在运行8
Thread-1正在运行9
Thread-1正在运行10
Thread-0正在运行3

创建多线程的第三种方式

线程的状态和生命周期

线程的状态

新建（New）：当你创建一个thread或者他的子类的时候进入新建状态
可运行（Runnable）：当已经创建好了线程对象，去调用start方法，进入可运行状态
正在运行(Running)：一个处于可运行状态的线程，一旦获取了CPU的使用权，就会进入此状态
堵塞（Blocked）
终止(Dead)

生命周期：五个状态之间的转换过程

sleep方法的使用

Thread类的方法

public static void sleep(long millis)

作用：在指定的毫秒数内让正在执行的线程休眠（暂停使用）
参数为休眠的时间，单位是毫秒

package com.imooc.sleep;
class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i=1;i<=15;i++){
            System.out.println(Thread.currentThread().getName()+"执行第"+i+"次！");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class SleepDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
    }
}

Thread-0执行第1次！
Thread-0执行第2次！
Thread-0执行第3次！
Thread-0执行第4次！
Thread-0执行第5次！
Thread-0执行第6次！
Thread-0执行第7次！
Thread-0执行第8次！
Thread-0执行第9次！
Thread-0执行第10次！
Thread-0执行第11次！
Thread-0执行第12次！
Thread-0执行第13次！
Thread-0执行第14次！
Thread-0执行第15次！

sleep结束后并不是直接进入运行状态，而是进入可运行状态，获取到cpu使用权后才能进入运行状态，所以上述代码实际时间可能比1000ms多一些。

package com.imooc.sleep;
class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i=1;i<=15;i++){
            System.out.println(Thread.currentThread().getName()+"执行第"+i+"次！");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class SleepDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
        Thread t1 = new Thread(mt);
        t1.start();
    }
}

Thread-0执行第1次！
Thread-1执行第1次！
Thread-1执行第2次！
Thread-0执行第2次！
Thread-1执行第3次！
Thread-0执行第3次！
Thread-0执行第4次！
Thread-1执行第4次！
Thread-0执行第5次！
Thread-1执行第5次！
Thread-1执行第6次！
Thread-0执行第6次！
Thread-1执行第7次！
Thread-0执行第7次！
Thread-1执行第8次！
Thread-0执行第8次！
Thread-1执行第9次！
Thread-0执行第9次！
Thread-1执行第10次！
Thread-0执行第10次！
Thread-0执行第11次！
Thread-1执行第11次！
Thread-0执行第12次！
Thread-1执行第12次！
Thread-1执行第13次！
Thread-0执行第13次！
Thread-1执行第14次！
Thread-0执行第14次！
Thread-1执行第15次！
Thread-0执行第15次!

一个线程执行完一条输出语句后就调用sleep休眠了，那么在它休眠的这段时间，另外一个线程去获取CPU使用权的几率大大提高，所以会出现两个线程交叉执行的现象

join的两种方法的使用

1

Thread类的方法

public final void join()
作用：等待调用该方法的线程结束后才能执行（也就是说一旦有一个线程调用了join方法就会有优先执行）

package com.imooc.join;

class MyThread extends Thread{
    public void run(){
        for (int i=1;i<=10;i++){
            System.out.println(getName()+"正在执行"+i+"次");
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        try {
            mt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 1; i < 20; i++) {
            System.out.println("主线程正在运行"+i+"次");
		}
        System.out.println("主线程运行结束！");
    }
}

Thread-0正在执行1次
Thread-0正在执行2次
Thread-0正在执行3次
Thread-0正在执行4次
Thread-0正在执行5次
Thread-0正在执行6次
Thread-0正在执行7次
Thread-0正在执行8次
Thread-0正在执行9次
Thread-0正在执行10次
主线程正在运行1次
主线程正在运行2次
主线程正在运行3次
主线程正在运行4次
主线程正在运行5次
主线程正在运行6次
主线程正在运行7次
主线程正在运行8次
主线程正在运行9次
主线程正在运行10次
主线程正在运行11次
主线程正在运行12次
主线程正在运行13次
主线程正在运行14次
主线程正在运行15次
主线程正在运行16次
主线程正在运行17次
主线程正在运行18次
主线程正在运行19次
主线程运行结束！

上述代码加入join方法后，会先运行调用join方法的线程，主线程会后运行

2

Thread类的方法

public final void join(long millis)

作用：等待该线程终止的最长时间为millis毫秒

前面那种没参数的方法是调用join方法的线程执行结束后其他线程才会执行，现在加入了一个参数，比如参数是1000，也就是说调用join方法执行1000ms后不管线程是否结束，都会继续执行其他线程

线程的优先级

java为线程类提供了10个优先级
优先级可以用整数1—10表示（数字越大优先级越高），超出范围会抛出异常
主线程默认优先级为5
除了用数字表示线程优先级还可以用优先级常量：
- -MAX_PRIORITY：线程的最高优先级10
- -MIN_PRIORITY：线程的最低优先级1
- -NORM_PRIORITY：线程的默认优先级5

thread类中提供了两个获取和改变优先级的方法：

package com.imooc.priority;

class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    public void run(){
        for (int i = 1; i <= 10; i++) {
            System.out.println("线程"+name+"正在运行"+i);
        }
    }
}

public class PriorityDemo {
    public static void main(String[] args) {
        //获取主线程的优先级
        int mainPriorit = Thread.currentThread().getPriority();
        System.out.println("主线程的优先级为："+mainPriorit);
        MyThread mt1 = new MyThread("线程1");
        //设置线程优先级
        mt1.setPriority(10);
        //mt1.setPriority(Thread.MAX_PRIORITY);
        mt1.start();
        System.out.println("线程1的优先级为："+mt1.getPriority());
    }
}

主线程的优先级为：5
线程1的优先级为：10
线程线程1正在运行1
线程线程1正在运行2
线程线程1正在运行3
线程线程1正在运行4
线程线程1正在运行5
线程线程1正在运行6
线程线程1正在运行7
线程线程1正在运行8
线程线程1正在运行9
线程线程1正在运行10

运行结果也是具有随机性的，线程优先级的设置跟操作系统的环境以及CPU的调度都有关系，结果不能完全保障优先级高的线程一定先执行

线程同步（线程互斥）

多线程运行问题：

各个线程是通过竞争CPU时间而获得运行机会的
各线程什么时候得到CPU时间，占用多久，是不可预测的
一个正在运行着的线程在什么地方被暂停是不确定的

synchronized关键字用在

成员方法
静态方法
语句块

public synchronized void saveAccount(){}

public static synchronized void saveAccount(){}

synchronized(obj){…} //obj就是被锁定的对象，大括号内表示需要进行同步的代码

被synchronized修饰后，该进程没执行完之前是不会被其他线程打断的

银行存库款问题

为了保证在存款或取款的时候，不允许其他线程对账户余额进行操作
需要将Bank对象进行锁定
使用关键字synchronized(同步)实现

同步

package com.imooc.bank;

public class Bank {
    private String account;//账号
    private int balance;//账户余额
    public Bank(String account,int balance){
        this.account=account;
        this.balance=balance;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Bank{" +
                "账号：" + account + '\'' +
                ", 余额：=" + balance +
                '}';
    }
    //存款
    public synchronized void saveAccount(){
        //获取当前的账号余额
        int balance = getBalance();
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //修改余额，存100
        balance+=100;
        //修改账户余额
        setBalance(balance);
        //输出存款后的账户余额
        System.out.println("存款后的账户余额为："+balance);
    }
    //取款
    public void drawAccount(){
        synchronized (this){
            //获取当前的账户余额
            int balance = getBalance();
            //修改余额，取200
            balance-=200;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改账户余额
            setBalance(balance);
            System.out.println("取款后的账户余额："+balance);
        }

    }
}

package com.imooc.bank;

public class DrawAccount implements Runnable {
    Bank bank;
    public DrawAccount(Bank bank){
        this.bank=bank;
    }
    @Override
    public void run() {
        bank.drawAccount();
    }
}

package com.imooc.bank;
//存款
public class SaveAccount implements Runnable {
    Bank bank;
    public SaveAccount(Bank bank){
        this.bank=bank;
    }
    @Override
    public void run() {
        bank.saveAccount();
    }
}

package com.imooc.bank;

public class Test {
    public static void main(String[] args) {
        //创建账户，给定余额为1000
        Bank bank = new Bank("1001",1000);
        //创建线程对象
        SaveAccount sa = new SaveAccount(bank);
        DrawAccount da = new DrawAccount(bank);
        Thread save = new Thread(sa);
        Thread draw = new Thread(da);
        save.start();
        draw.start();
        try {
            save.join();
            draw.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(bank);

    }
}

线程间通信

package com.imooc.queue;

public class Queue {
    private int n;
    boolean flag=false;

    public synchronized int getN() {
        if (!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费:"+n);
        flag=false;//消费完毕，容器中没有数据
        notifyAll();
        return n;
    }

    public synchronized void setN(int n) {
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产:"+n);
        this.n = n;
        flag=true;//生产完毕，容器中已经有数据
        notifyAll();
    }
}

package com.imooc.queue;

import com.imooc.runable.PrintRunnable;

public class Producer implements Runnable {
    Queue queue;
    Producer(Queue queue){
        this.queue=queue;
    }
    @Override
    public void run() {
        while (true){
            int i = 0;
            while (true){
                queue.setN(i++);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

package com.imooc.queue;

public class Consumer implements Runnable {
    Queue queue;
    Consumer(Queue queue){
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true){
            queue.getN();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.imooc.queue;

public class Test {
    public static void main(String[] args) {
        Queue queue = new Queue();
//        Producer pr= new Producer(queue);
//        Thread save = new Thread(pr);
//        save.start();
        new Thread(new Producer(queue)).start();//上面三行代码可简化成这一行代码
        new Thread(new Consumer(queue)).start();

    }
}