java多线程

_CYX_

已于 2024-07-30 17:09:38 修改

阅读量661

点赞数 25

分类专栏： Java 文章标签： java 开发语言

于 2024-07-30 17:08:41 首次发布

本文链接：https://blog.csdn.net/qq_65186476/article/details/140794513

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

获取当前线程的名字

Thread.currentThread().getName()

Thread类实现了Runnable接口，重写了Runnable接口里的run方法

创建线程的两种方式

1、继承Thread类

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();
    }
}

class Cat extends Thread {
    @Override
    public void run() {
        System.out.println("一秒执行一次");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

细节：

程序开始运行，进程就启动了，程序会进入到main方法中开始main线程，然后cat.start()建立一个子线程，main线程不会阻塞，会继续执行
如果main线程执行60次，子线程执行80次，那么main线程会先挂掉，然后子线程挂掉，最后进程结束，所以主线程结束并不会造成整个进程结束

启动线程cat.start()最终会执行cat的run方法

为什么启动线程用的是cat.start();而不是直接用cat.run();
run方法只是一个普通方法，他并没有开启一个新的线程，仍然是主线程在运行，导致主线程会发生阻塞（即系统会执行完run方法中的所有内容后再开始执行主线程中的后续代码）
当我们调用cat.start();时，系统会进入public synchronized void start() {} 这个方法，start0()是一个本地方法，由JVM调用，底层由c/c++实现，真正实现多线程效果的是start0()方法,而不是run()方法，最后再在start0()方法中调用run()方法

2、实现Runnable接口

java是单继承，A类已经继承B类，无法再继承Thread类，所以只能实现Runnable接口

因为Runable接口当中只有run() 方法，因此不能直接调用start()方法，所以需要一个代理（即创建一个Thread对象，将实现Runnable接口的类当作参数输入），然后再通过调用Thread对象中的start()方法完成线程的创建。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        Thread thread = new Thread(cat);
        thread.start();
        for(int i = 0; i < 10; i ++) {
            System.out.println(i);
            Thread.sleep(1000);
        }
    }
}

class Cat implements Runnable {
    @Override
    public void run() {
        while(true) {
            System.out.println("一秒输出一次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

模拟代理模式


class Animal {
}
 
class Tiger extends Animal implements Runnable {
 
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    }
}
public class Thread02 {
    public static void main(String[] args) {
 
        Tiger tiger = new Tiger();//实现了 Runnable
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
 
    }
}
//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy
 
    private Runnable target = null;//属性，类型是 Runnable
 
    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }
 
    public ThreadProxy(Runnable target) {
        this.target = target;
    }
 
    public void start() {
        start0();//这个方法时真正实现多线程方法
    }
 
    public void start0() {
        run();
    }
}

区别

（1）从Java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，因为Thread类本身就实现了Runnable接口；

（2）实现Runnable接口方式更适合多个线程共享一个资源的情况，并且避免了单继承限制。推荐使用Runnable；

下图程序当中，线程thread01和thread02就共享了t3。

线程终止

① 当线程完成任务后，会自动退出；

② 通过使用变量来控制run方法退出的方式停止线程，即通知方式。

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
 
        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式
 
        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}
 
class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
 
            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }
 
    }
 
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程方法

（1）setName //设置线程名称，使其与参数name相同；

（2）getName //返回该线程的名称；

（3）start //使该线程开始执行；Java虚拟机底层调用该线程的start0方法；

（4）run //调用线程对象run方法；

（5）setPriority //更改线程的优先级；

（6）getPriority //获取线程的优先级；

（7）sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；

（8）interrupt //中断线程，注意不是终止，如果线程正在休眠，则停止休眠，继续执行。

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("老韩");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程
 
 
        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for(int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
 
        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1
 
        t.interrupt();//当执行到这里，就会中断 t线程的休眠.
 
 
 
    }
}
 
class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

线程插队

（1）yield：线程的礼让

让出CPU，让其他线程执行，但是礼让的时间不确定，所以不一定礼让成功。
线程T执行了yield方法，如果资源不紧张，cpu认为没有必要让出资源，就会不成功。

（2）join：线程的插队

插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务。

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
 
        T2 t2 = new T2();
        t2.start();
 
        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }
 
        }
    }
}
 
class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

守护线程

（1）用户线程（也叫工作线程）:当线程的任务执行完或通知方式结束。
（2）守护线程：一般是为工作线程服务的，当所有的用户线程结束后，守护线程就自动结束了。
当主线程退出，子线程即使是无限循环也要退出
（3）常见的守护线程：垃圾回收机制。

线程名.setDaemon(true);

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //,只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
 
        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}
 
class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
        }
    }
}

线程的生命周期

线程有六种状态：

New: 尚未启动的线程
Runnable（可以运行，但是否运行取决于调度器）
分为：Running:运行的 Ready: 准备运行的
Blocked: 被阻塞的
Wating: 等待中
TimedWating: 等待另一个线程执行动作达到指定等待时间
Terminated: 已退出的

线程同步

（1）在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性；

（2）线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直至该线程完成操作，其他线程才能对该内存地址进行操作。

具体方法-Synchronized

（1）同步代码块

        synchronized（对象）{ //得到对象的锁，才能操作同步代码
                需要被同步代码；
        }

（2）同步方法，synchronized放在方法声明中，表示整个方法为同步方法

        public synchronized void m（String name）{
                需要被同步的代码
        }

互斥锁

同步方法（非静态）的锁可以是this，也可以是其他对象（要求是同一个对象）
同步方法（静态）的锁为当前类本身

非静态

在方法加锁

public synchronized void sell(){//就是一个同步方法，锁在this对象
            if (ticketNum <= 0) {
            }
        
    }

在代码块加锁

public void sell(){
        synchronized(this){//此时锁在this对象
            if (ticketNum <= 0) {
            }
        
    }

在同一个对象加锁

Object object = new Object();//这个类是作为类的成员
public void sell(){
        synchronized(object){
            if (ticketNum <= 0) {
            }
        
    }

静态

在静态方法加锁

public synchronized static void m1(){ //锁是加在类上的
}

在静态方法的同步代码块中加锁，写类名.class，静态方法中不能直接写this

public static void m2(){
    synchronized(类名.class) { //不能写this
    }
}

细节：

同步方法如果没有static修饰，默认锁对象为：this
如果方法使用static修饰，默认所对象为：当前类.class
选择合适的同步代码块和同步方法，要求多个线程的锁对象为同一个
如果使用继承Thread来创建多线程,那么只能使用静态方法锁类,否则不是同一对象;如果实现Runnable接口,则只能创建一个对象!

死锁

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

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
    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");
                }
            }
        }
    }
}