线程学习(2)线程创建,等待,安全,synchronized（一）-阿里云开发者社区

线程学习(2)线程创建,等待,安全,synchronized（一）

2024-01-08 108

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 线程学习(2)线程创建,等待,安全,synchronized（一）

💕"i need your breath"💕

作者：Mylvzi

文章主要内容：线程学习(2)

前情回顾：

在上一篇博客中介绍到了进程与线程的区别，以及初步了解如何在Java实现多线程编程，通过内置的Thread类来实现多线程，充分利用多核cpu资源，要充分认识到每一个线程都是一个独立的"执行流"，本篇文章继续讲解和Thread有关的一些操作

一.Thread类的创建方式

1.继承Thread 重写run

//创建一个类  继承于Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程的入口  告诉线程要执行哪些逻辑
            System.out.println("hello thread");
            try {
                // 休眠1s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 首先要实例化出一个Thread类
        Thread thread = new MyThread();
//         start和run都是Thread类的成员
//         run只是告诉线程要去执行那些逻辑
//         start是真正的调用系统的api，创建出一个线程，再让线程去执行run
        thread.start();
//        thread.run();
        while (true) {
            System.out.println("hello main");
            // 休眠1s
            Thread.sleep(1000);
        }
    }
}

2.实现Runnable 重写run

创建自定义类时让其实现Runnable接口，这样写的原因本质在于Thread类也实现了Runnable接口

class MyThread implements Runnable {
    @Override
    public void run() {
        while(true) {
            System.out.println("==");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        // 使用向上转型 是Java生态中的常见方式
        // 先实现一个Runnable接口
        Runnable runnable = new MyThread();
        Thread thread = new Thread(runnable);
        thread.start();
        while (true) {
            System.out.println("==");
            Thread.sleep(1000);
        }
    }
}

说明：

Runnable表示的是一个"可以运行的任务"，这个任务是交给线程执行还是交给其他是体执行，Runnable本身并不关心~

Runnable接口用来表示一个可以在线程中单独执行的任务，一个类只要实现了Runnable接口并且实现他的run方法，那么这个类的实例就能够单独在线程中执行，Runnable接口就像是一个点石成金的"魔法师"，只要被他修饰过，就具有了"可被执行"的属性，这个任务不仅仅可以通过线程来执行，也可以通过线程池和执行器来执行

使用Runnable接口有哪些好处呢?直接继承Thread类不是更简单么?使用Runnable接口最大的好处就是可以"解耦合"，降低代码之间的联系性，代码之间的联系性越高，耦合度就越高；反之亦然，耦合度过高不利于我们之后对代码进行修改~就像你和你最好的哥们一起创业，分钱肯定是不好分的~

上述两种创建Thread类的方式有所不同，第一种是直接通过MyThread类来实例化一个Thread类，第二种是先通过MyThread类先实例化一个Runnable接口，再通过这个接口去实例化一个Thread类。为什么第二种方式耦合度更低呢？原因在于第二种方式自定义类和Thread类之间的联系性降低了，他们之间是通过Runnable接口来联系起来的，以后使用更多线程的时候就都可以通过Runnable这个接口来实现，请看第二种方式创建线程的图解

第一种方式的图解

很明显第二种方式代码之间的耦合性更低

3.继承Thread，重写run，使用匿名内部类

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        // 继承Thread  使用匿名内部类
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

4.实现Runnable 重写run，使用匿名内部类

public class Demo11 {
    public static void main(String[] args) {
        // 实现Runnable  重写run  使用匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        Thread t = new Thread(runnable);
        t.start();
    }
}

5.使用lambda表达式+Runnable接口（推荐方式）

Runnable接口是一个函数式接口，只有一个抽象方法run，所以可以使用lambda表达式来实现

public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        // 使用lambda表达式
        Runnable runnable = () -> {
            while (true) {
                System.out.println("Mythread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        while (true) {
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

使用这种方式创建线程，代码既简洁，又优雅，耦合性也低，推荐大家使用这种方式创建线程

Thread类的其他构造方法

Thread(String name) 创建线程对象，并命名

这个构造方法主要用于给线程命名，方便后续进行调试

// 可以为线程起一个名字作为标识  对线程的执行没有影响  就是单纯的一个"标识"  方便之后调试进行检查区分
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"这是一个线程名字");

Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名【了解】Thread(ThreadGroup group, Runnable target) 线程可以被用来分组管理，分好的组即为线程组

二.Thread类的一些属性

1.ID

线程的唯一标识，是Java为每个线程分配的"身份标识"

获取方法

getId()

Thread t = new Thread();
        long tid = t.getId();// 返回值是一个长整型
        System.out.println("线程ID：" + tid);// 输出线程ID：20

2.名称name

就是线程的名字，便于后序进行调试

获取方法

getName()

Thread t = new Thread("我是线程");
        String tName = t.getName();
        System.out.println(tName);// 输出我是线程

注意：此方法在源码中是被final修饰的，意味着子类无法重写方法

3.状态 state

进程最常见的两种状态是就绪状态和阻塞状态，线程也有自己的一些属性

// 获取线程的所有状态
        for (Thread.State state : Thread.State.values()) {
            System.out.print(state+" ");
        }

NEW Thread 对象已经存在但是还没有通过start方法调用
RUNNABLE 就绪状态线程已经在cpu上执行/等在在cpu上执行
TERMINATED Thread对象还在但系统内核中的线程不存在
TIMED_WAITING 阻塞由于sleep这种固定时间的方式产生的阻塞
WAITING 阻塞由于wait这种不固定时间的方式产生的阻塞
BLOCKED 阻塞由于锁竞争导致的阻塞

Thread t = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(t.getState());// Thread类存在，但是还没有调用start方法，状态为NEW
        t.start();
        System.out.println(t.getState());// RUNNABLE
        Thread.sleep(3000);
        System.out.println(t.getState());// TERMINATED

4.优先级priority

获取线程的优先级

获取方法

getPriority

Thread t = new Thread("我是线程");
        int tPriority = t.getPriority();
        System.out.println(tPriority);

说明：其实此方法很"鸡肋"，因为线程的优先级是由cpu的调度器决定的，在我们写代码的过程中很少去关注优先级，一是我们根本就观察不到，二是根本也没这个必要

线程学习(2)线程创建,等待,安全,synchronized（二）+https://developer.aliyun.com/article/1413578

线程学习(2)线程创建,等待,安全,synchronized（一）

一.Thread类的创建方式

1.继承Thread 重写run

2.实现Runnable 重写run

3.继承Thread，重写run，使用匿名内部类

4.实现Runnable 重写run，使用匿名内部类

5.使用lambda表达式+Runnable接口（推荐方式）

二.Thread类的一些属性

1.ID

2.名称name

3.状态 state

4.优先级priority

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

线程学习(2)线程创建,等待,安全,synchronized（一）

一.Thread类的创建方式

1.继承Thread 重写run

2.实现Runnable 重写run

3.继承Thread，重写run，使用匿名内部类

4.实现Runnable 重写run，使用匿名内部类

5.使用lambda表达式+Runnable接口（推荐方式）

二.Thread类的一些属性

1.ID

2.名称name

3.状态 state

4.优先级priority

热门文章

最新文章

相关电子书