首页 > 编程语言 >Java---线程入门

Java---线程入门

时间：2022-09-05 22:59:37浏览次数：191  
标签：Java Thread void T0 --- 线程 new public

前置知识

什么是进程，什么又是线程？咱不是讲系统，简单说下，知道个大概就好了。

进程：一个可执行文件执行的过程。
线程：操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务

什么是并行，什么是并发？这个也简单说下。

并行：cpu的两个核心分别执行两个线程。
并发：cpu的一个核心在两个(或多个)线程上反复横跳执行。

线程的创建

继承Thread

// 声明
class T extends Thread {
    public void run() {
        // do something
    }
}
// 使用
new T().start();

实现Runnable

// 声明
class T implements Runnable {
    public void run() {
        // do something
    }
}
// 使用
new Thread(new T()).start();

为什么是start，而不是run，其实run只是个很普通的方法，我们来看看start的源码。

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0(); // 这个才是开启线程
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
        }
    }
}
// start0的实现
private native void start0(); // 这是一个native方法，通常使用C/C++来实现

多线程机流程（从启动到终止）

我们通过一个案例来说明。

顺便说说sleep()

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new T0(), "T0").start();
        int cnt = 0;
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(200); // 让当前线程停止200毫秒
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(200); // 让当前线程停止200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行流程：

  1. 启动main方法(进程开启)
  2. 启动main线程
  3. 打印main/打印T0(根据线程调度执行)
  4. 其中一个线程结束
  5. 另一个线程结束
  6. 进程结束

线程常用方法

  • setName：设置线程名称，不设置则使用默认线程名称。

  • getName：获取线程名称。

  • start：开启线程。实际开启线程的方法为start0。

  • run：调用start后创建的新线程会调用run方法。单纯调用run方法无法达到多线程的效果，run方法只是个普通的方法。

  • setPriority：更改线程优先级。

  • getPriority：获取线程优先级。

    线程的优先级：
public static final int MIN_PRIORITY = 1;
public static final int NORM_PRIORITY = 5;
public static final int MAX_PRIORITY = 10;

  • sleep：让线程休眠指定时间。

线程终止

虽然Thread中提供了一个stop方法用来停止线程，但目前已经被废弃。那么我们如何停止线程呢？我们来看看下面这个例子。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        new Thread(t0, "T0").start();
        int cnt = 0;
        while (cnt < 50) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
        }
        t0.flag = false; // 设置为false用以跳出T0线程的循环
        /*
        	在main线程执行了50次后退出T0线程，接着退出main线程
         */
    }
}
class T0 implements Runnable {
    boolean flag = true; // 定义一个标记，用来控制线程是否停止
    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

通过定义一个标记flag让线程退出。

线程中断

Thread中有一个interrupt方法，这个方法不是说中断线程的运行，而是中断线程当前执行的操作。我们来看下样例。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "T0");
        thread0.start();
        System.out.println("张三在划水。。。");
        Thread.sleep(2000);
        thread0.interrupt(); // 通过抛出一个InterruptedException异常来打断当前操作(sleep)
    }
}
class T0 implements Runnable {
    boolean flag = true;
    @Override
    public void run() {
        System.out.println("李四在打盹。。。");
        while (flag) {
            try {
                Thread.sleep(20000); // 2秒后被interrupt中断
            } catch (InterruptedException e) {
                flag = false;
                System.out.println("老板来了，张三摇醒了李四。。。"); // 由于main线程调用了interrupt，实际过了2秒就输出了
            }
        }
    }
}

输出结果：

张三在划水。。。
李四在打盹。。。
老板来了，张三摇醒了李四。。。

线程让步

Thread类中提供了yield方法，用来礼让cpu资源。礼让了资源就会执行其他线程吗？我们看看这个例子

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "T0");
        thread0.start();
        int cnt = 0;
        while (cnt < 5) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.yield(); // 放弃当前的cpu资源，让cpu重新分配资源。
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        int cur = 0; // 连续吃的包子数
        while (cnt < 5) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            Thread.yield(); // 放弃当前的cpu资源，让cpu重新分配资源。
        }
    }
}

输出结果：

main
T0
main
main
main
main
T0
T0
T0
T0

可以看到两个线程互相礼让，如果yield方法会强制执行其他线程的话，那线程应该会交替执行，而不是有连续执行同一个线程的情况。所以证明了yield并不是强制礼让。

线程插队

Thread类提供了join方法，可以指定一个线程优先执行。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread0 = new Thread(new T0(), "T0");
        thread0.start();
        Thread thread1 = new Thread(new T0(), "T1");
        thread1.start();
        int cnt = 0;
        while (cnt < 2) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
            thread0.join(); // 让线程thread0插队，执行完thread0的所有任务后回到当前线程。
        }
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        int cur = 0;
        while (cnt < 2) {
            cnt ++;
            System.out.println(Thread.currentThread().getName());
        }
    }
}

输出结果：

main
T1
T1
T0
T0
main

总体上main线程确实被T0插队了，但为啥T1在T0的前面被执行？因为当前是多核CPU的环境，其它的核心在执行剩下的线程，执行T1线程的核心比T0的快所以T1在T0之前被输出。不止有并发，还有并行。在单纯并发的条件下，就变成了T0的所有任务都执行完毕后，才会执行其他线程。当前的main与T0是并发的，与T1是并行。

守护线程

Thread类提供setDaemon方法，可以设置目标线程为当前线程的守护线程，当前线程终止时，目标(守护)线程也随之终止。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread0 = new Thread(new T0(), "T0");
        thread0.setDaemon(true);
        thread0.start();
        System.out.println("张三 --> 新一天的工作开始了");
        int time = 0;
        while (time < 8) { // 张三每天工作八个小时。。。
            time ++;
        }
        System.out.println("张三 --> 下班了，回家吃老婆做的饭咯");
        System.out.println("小红 --> 我老公张三下班了，今天就到这了");
        System.out.println("小红 --> 守护线程YYDS");
    }
}
class T0 implements Runnable {
    int cnt;
    @Override
    public void run() {
        System.out.println("小红 --> 李四来我家甜蜜双排王者荣耀");
        while (true);
    }
}

输出结果：

张三 --> 新一天的工作开始了
小红 --> 李四来我家甜蜜双排王者荣耀
张三 --> 下班了，回家吃老婆做的饭咯
小红 --> 我老公张三下班了，今天就到这了
小红 --> 守护线程YYDS

当main线程终止时，T0线程也终止。

线程的状态

5种状态是OS的线程状态。而6种则说的是JVM的线程状态。以下是状态图。

线程状态

OS的线程状态为粗体
JVM的线程状态为英文

线程同步机制

想看个经典问题。

多线程售票问题

我们来看看案例。

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "张三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public void run() {
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("%s买了一张票，还剩%d张%n", Thread.currentThread().getName(), -- ticket);
        }
    }
}

输出结果：

...
张三买了一张票，还剩3张
张三买了一张票，还剩2张
李四买了一张票，还剩1张
张三买了一张票，还剩0张
李四买了一张票，还剩0张

出现了重复卖票，造成这种现象的原因是线程不安全。那如何让线程安全呢。这就是接下来要介绍的互斥锁。

互斥锁

java提供了synchronized关键字用以开启锁。看看如何使用锁解决上面的线程安全问题。

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "张三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public synchronized void run() { // 我们将锁加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("%s买了一张票，还剩%d张%n", Thread.currentThread().getName(), -- ticket);
        }
    }
}

输出结果：

...
张三买了一张票，还剩4张
张三买了一张票，还剩3张
张三买了一张票，还剩2张
张三买了一张票，还剩1张
张三买了一张票，还剩0张

所有的输出都在线程张三上，这显然不是我们想要的。
首先，为什么会有这种现象发生？其实，被synchronized修饰的方法或代码块会被上锁，并发环境下先进入该方法或者代码块的线程将获得锁并执行这部分代码，而其他线程则处于阻塞状态直到获得锁的线程执行完被上锁的所有代码后，其他线程才有机会去争夺锁。

上述现象的原因是synchronized修饰了整个方法，所以当张三拿到锁时会执行完所有的循环后释放锁，这时李四就什么都输出不了了，和单线程一样，除了多了个一直阻塞的线程，性能低下。

那么如何保证线程安全的前提下，保证并发的性能呢？第一次尝试解决。

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "张三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public /*synchronized*/ void run() { // 我们将锁加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(this) { // 存在两个线程执行时都满足ticket>0,仍然有线程安全问题  
                System.out.printf("%s买了一张票，还剩%d张%n", Thread.currentThread().getName(), -- ticket);
            }
        }
    }
}

输出结果：

...
李四买了一张票，还剩3张
李四买了一张票，还剩2张
张三买了一张票，还剩1张
张三买了一张票，还剩0张
李四买了一张票，还剩-1张

虽然两个线程恢复了并发，但线程安全问题也随之出现。

第二次尝试解决。

public class ThreadTest {
    public static void main(String[] args) {
        T0 t0 = new T0();
        Thread thread0 = new Thread(t0, "张三");
        Thread thread1 = new Thread(t0, "李四");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    int ticket = 100;
    @Override
    public /*synchronized*/ void run() { // 我们将锁加在run方法上
        while (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(this) {
                if (ticket <= 0) return; // 在同步代码块中再次判断以确保线程安全
                System.out.printf("%s买了一张票，还剩%d张%n", Thread.currentThread().getName(), -- ticket);
            }
        }
    }
}

输出结果：

...
李四买了一张票，还剩4张
李四买了一张票，还剩3张
张三买了一张票，还剩2张
张三买了一张票，还剩1张
李四买了一张票，还剩0张

通过在同步代码块中再次判断以达到线程安全。

死锁

并发编程中不只有线程安全问题，还有死锁问题。

public class ThreadTest {
    public static void main(String[] args) {
        String lock1 = "A";
        String lock2 = "B";
        String lock3 = "C";
        Thread t0 = new Thread(new T0(lock1, lock2));
        Thread t1 = new Thread(new T0(lock2, lock3));
        Thread t2 = new Thread(new T0(lock3, lock1));
        t0.start();
        t1.start();
        t2.start();
    }
}
class T0 implements Runnable {
    String lock1;
    String lock2;
    T1(String lock1, String lock2) {
        this.lock1 = lock1;
        this.lock2 = lock2;
    }
    @Override
    public void run() {
        synchronized(lock1) {
            System.out.println("获取锁: " + lock1);
            synchronized(lock2) {
                System.out.println("获取锁: " + lock2);
            }
            System.out.println("释放锁: " + lock2);
        }
        System.out.println("释放锁: " + lock1);
    }
}

输出结果：

获取锁：B
获取锁：A
获取锁：C

可以看出三个线程分别持有一把锁，相互锁住不能释放，形成死锁。
为了不写出死锁的并发代码，我们需要学习释放锁的时机。

释放锁

  • run执行完毕，释放锁。

  • wait执行，释放锁。

  • sleep执行，不会释放锁。

  • join执行，不会释放锁，而是挂起当前线程。

  • notify执行，不会释放锁。

    public class ThreadTest {
    public static void main(String[] args) {
        String lock = "A";
        Thread thread0 = new Thread(new T0(lock), "T0");
        Thread thread1 = new Thread(new T1(lock), "T1");
        thread0.start();
        thread1.start();
    }
}
class T0 implements Runnable {
    String lock;
    public T0(String lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        synchronized(lock) {
            System.out.println(Thread.currentThread().getName() + "获取锁");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "释放锁");
        }
    }
}
class T1 implements Runnable {
    String lock;
    public T1(String lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
            synchronized(lock) {
                System.out.println(Thread.currentThread().getName() + "获取锁");
                lock.notify();
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + "释放锁");
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

    输出结果：

    T0获取锁
T1获取锁
T1释放锁
T0释放锁

​ 证明notify并不会释放锁，只是通知一个wait的线程：Waiting → Runnable(Ready)，接着在调用notify的线程执行完毕后释放锁。

标签：Java,Thread,void,T0,---,线程,new,public
From： https://www.cnblogs.com/buzuweiqi/p/16641509.html

相关文章

  • 股票分析-市盈率
    PE市盈率=股价/每股收益=总市值/净利润租售比：房子的价格/每年租金投资某一项回本的年限（PE）1*市盈率（PE）在12到14倍之间是符合（回本期限）动态：当总市值/今年（估算今年的净利润......
  • Java运行机制
    编译型语言和解释型语言然而Java既是编译型语言，又是解释性语言。Java的运行机制如下：graphTBA("Java源码(*.java文件)")-->B(Java编译器) B-->D("字节码(*.c......
  • k8s--CronJob（CJ） 控制器
    CronJob介绍CronJob控制器以Job控制器资源为其管控对象，并借助它管理pod资源对象，job控制器定义的作业任务在其控制器资源创建之后便会立即执行，但CronJob可以以类......
  • 每周一坑-管理端和手机端版本号不一致
    管理端和手机端版本号不一致话说A系统的生产环境，管理端和手机端前端静态目录是分开的，分别部署在两台服务器上，但，其实目录内容是完全一样的。其他环境（测试、体验）则合在......
  • 2022-9-5
    2022-9-5HWS2022-Re1这题也算复习了一下tea，踩了一下几个做题的坑，希望自己下次做tea的时候可以注意1.注意ida的赋值问题，要了解出题人的代码规范和习惯2.注意sum值的变化......
  • Javascript简介
    ​ /**作者：呆萌老师*☑csdn认证讲师*☑51cto高级讲师*☑腾讯课堂认证讲师*☑网易云课堂认证讲师*☑华为开发者学堂认证讲师*☑爱奇艺千人名师计划成员*在这里......
  • 浅析mysql报错：Error writing file '/tmp/MY4QWdUa' (Errcode: 28 - No space left on
    一、问题背景1、报错描述：今天执行sql时发现Node服务的日志报错：SequelizeDatabaseError:EE_WRITE:Errorwritingfile'/tmp/MY4QWdUa'(Errcode:28-Nospac......
  • JavaScript: stringify
     constobj={name:'qwer',hobbies:['op','nm'],year:2022,fn:function(){},//functionignorereg:newRegExp(),//RegExp{......
  • 为什么要写成mid=left+(right-left)/2
    我来解释一下，为什么要写成mid=left+(right-left)/2，而不是mid=(left+right)/2。因为会溢出！！此时的溢出指的是，mid可能会超出该数据类型的最大值我们假定一个数据类型uint8......
  • Flink-状态管理
     流式计算分为无状态和有状态两种情况。无状态的计算观察每个独立事件，并根据最后一个事件输出结果。例如，流处理应用程序从传感器接收温度读数，并在温度超过90度时发......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99