java并发编程学习一——Thread

最新推荐文章于 2023-06-27 12:00:22 发布
最新推荐文章于 2023-06-27 12:00:22 发布
阅读量192 收藏
点赞数 1
分类专栏： java并发编程 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yx444535180/article/details/126246434
版权

文章目录

一、常用方法

function_namestatic功能说明注意
start()否启动一个线程，在新线程中执行run方法中的代码start方法只是让线程就绪，并不是马上执行（CPU时间片还没分配给它），start方法只能调用一次，再次调用会报IllegalThreadStateException
run()否新线程启动之后会调用的方法如果在Thread的构造方法传入了Runnable参数，则线程启动执行Runnable的run方法，否则不执行任何操作。可以继承Thread来重写run方法，覆盖默认行为
join()否等待线程运行结束
join(long n)否等待线程运行结束，最多等待n毫秒
getId()否获取线程的长整型idid唯一
getName()否获取线程名
setName(String)否设置线程名
getPriority()否获取线程优先级
setPriority(int)否设置线程优先级java规定线程优先级是1-10的整数，数值越大优先级越高，被cpu调度的概率越大
getState()否获取线程状态线程状态有6中，定义在枚举中：NEW、RUNNABLE、BLOCKED、WAIT、TIMED_WAIT、TERMINATED
isAlive()否线程是否存活（尚未运行完）
interruput()否给线程添加中断标记RUNNABLE、BLOCKED状态的线程只是添加中断标记，不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException，并将线程状态改为RUNNABLE，同时清除中断标记
isInterrupted()否判断当前线程的中断标记，不会清除标记
interrupted()是判断当前线程的中断标记，会清除标记
currentThread()是获取当前正在运行的线程对象
sleep(long n)是让当前正在运行的线程休眠n毫秒，让出cpu时间片，但不会释放锁
yield()是让出cpu时间片，进入就绪状态，重新等待调度，会释放锁主要用于测试和调试

二、主要方法详解

2.1 start与run

start可以启动一个线程，run里面操作可以看做线程的任务。直接调用run方法，会在主线程执行run里面的操作，这块比较简单就不写demo了。

2.2 sleep与yield

sleep：

  • RUNNABLE(running)状态进入TIMED_WAITING
  • 其他线程可以使用interrupt方法打断正在睡眠的线程，抛出InterruptedException
  • 打断之后睡眠结束，但未必立即执行
  • 建议使用TimeUnit的sleep代替Thread的sleep

演示代码：

public class SleepAndYield {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
//                Thread.sleep(2000);
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");
        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(t1.getState());

        t1.interrupt();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t1.getState());

    }
}

yield:

  • RUNNABLE(running)状态进入RUNNABLE(runnable)
  • 让出cpu时间片执行其他同优先级的线程，如果没有同优先级的线程，那么不保证当前线程的暂停效果
  • 具体线程的执行依赖操作系统的任务调度器

演示代码：

public class SleepAndYield1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int count =0;
            while (true){
                System.out.println("t1----->"+count++);
            }
        },"t1");

        Thread t2 = new Thread(() -> {
            int count =0;
            while (true){
                Thread.yield();
                System.out.println("            t2----->"+count++);
            }
        },"t2");

        t1.start();
        t2.start();
    }
}

2.2.1 Thread.yield()和Thread.sleep(0)区别

无锁下相同：

  • Thread.yield()和Thread.sleep(0)都会让线程放弃剩余的cpu时间片，重新变为RUNNABLE状态，并放到同优先级线程队列的末尾等待cpu资源

有锁下不同：

  • Thread.yield()会让当前线程让出持有的锁，和其他线程去争抢锁，状态变为BLOCKED
  • Thread.sleep(0)并不会让出锁，依然是锁的持有者，状态还是RUNNABLE

2.3 join

join方法等待所属线程对象的线程执行结束，会阻塞调用它的线程
演示代码：

public class Join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> sleep(1), "t1");

        Thread t2 = new Thread(() -> sleep(2), "t2");

        t1.start();
        t2.start();
        long start =System.currentTimeMillis();
        t1.join();
        t2.join();
        long end =System.currentTimeMillis();
        System.out.println(end-start);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

限时等待

public class JoinN {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> sleep(2), "t1");
        t1.start();
        long start =System.currentTimeMillis();
        t1.join(1000);
        long end =System.currentTimeMillis();
        System.out.println(end-start);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.4 interrupt

RUNNABLE、BLOCKED状态的线程只是添加中断标记，不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException，并将线程状态改为RUNNABLE，同时清除中断标记。
打断WAIT、TIMED_WAIT线程：

public class Interrupt1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> sleep(2), "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打断RUNNABLE线程：
不能让t1线程停止运行

public class Interrupt2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true){

            }
        }, "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }

加判断让t1线程停止运行

public class Interrupt2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if(Thread.interrupted()){
                    System.out.println("被打断了...");
                    break;
                }

            }
        }, "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        //输出false，因为interrupted()会清除打断标记
        System.out.println("打断标记：" + t1.isInterrupted());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.4.1 两阶段interrupt停止线程

public class Interrupt3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("执行监控");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //二阶段打断
                    Thread.currentThread().interrupt();
                }

                if(Thread.interrupted()){
                    System.out.println("被打断了...");
                    break;
                }

            }
        }, "t1");
        t1.start();
        Thread.sleep(3500);
        //一阶段打断，t1线程正好在睡眠中，标记的打断会被清除，因此需要在catch块添加二阶段打断
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }
}

2.4.2 interrupt打断park线程

public class Interrupt4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("before park");
            LockSupport.park();
            System.out.println("after interrupt");
            //被标记打断的线程，再次park，无法暂停
            LockSupport.park();
            System.out.println("can't park");
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
        System.out.println("结束");
    }
}

2.5 setDaemon

setDaemon将设置线程为守护线程，顾名思义守护其他线程的线程，当没有线程需要守护，自己就强制结束了。

public class SetDaemon {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("Daemon main thread");
            }

        }, "t1");
        t1.setDaemon(true);
        t1.start();
        sleep(1);
        System.out.println("main thread over!");

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

三、线程状态

3.1 OS层面

OS层面有以下五种状态：初始状态–>可运行–>运行中–>阻塞–>终止
在这里插入图片描述

  • 初始状态：在编程语言创建了线程，还未提交到操作系统进行关联
  • 可运行状态：已提交到操作系统的任务调度器，等待被调度运行
  • 运行状态：获得了CPU时间片正在运行，与可运行状态来回切换即CPU上下文切换
  • 阻塞状态：执行阻塞任务中，例如调用阻塞IO，这时线程不占用CPU，导致上下文切换进入阻塞状态。阻塞任务完成之后会被操作系统唤醒，重新进入可运行状态等待调度。阻塞状态的线程只要不被唤醒，调度器就不会考虑调度它
  • 终止状态：线程执行完毕，生命周期结束，不再转换其它状态

3.2 JVM层面

Java语言中，在Thread类定义了一个状态枚举，表示线程的状态，有以下六种：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。看下六种状态对应的代码

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
            }
        }, "t2");
        t2.start();

        Thread t3 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t3");
        t3.start();

        Thread t4 = new Thread(() -> sleep(1000), "t4");
        t4.start();

        Thread t5 = new Thread(() -> {
            synchronized (ThreadState.class) {
            }
        }, "t5");
        t5.start();

        Thread t6 = new Thread(() -> {
        }, "t6");
        t6.start();
        Thread.sleep(2);
        System.out.println("t1：" + t1.getState());
        System.out.println("t2：" + t2.getState());
        System.out.println("t3：" + t3.getState());
        System.out.println("t4：" + t4.getState());
        System.out.println("t5：" + t5.getState());
        System.out.println("t6：" + t6.getState());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

再看下状态转换图简易版
在这里插入图片描述

  • 初始状态（NEW），线程对象被创建出来就进入了初始状态
  • 可运行状态（RUNNABLE），包含了操作系统中的运行、可运行、和一部分阻塞。自身又可细分为就绪和运行中
    • 就绪，线程进入了调度器队列，尚未被调度
    • 运行中，被调度器调度，从而获得CPU时间片正在运行
  • 阻塞（BLOCKED），线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态
  • 等待（WAITING），进入等待的线程，需要被显示唤醒才能再次进入可运行状态，否则将一直等待下去
  • 超时等待（TIMED_WAITING）与等待状态的区别是，有时间期限，到时自动唤醒
  • 终止（TERMINATED），run方法里的任务执行完就进入终止状态，线程对象也许还存活，但无法再次调用start，否则将抛出异常

3.3 OS与JVM线程状态对比

在这里插入图片描述
如图所示：开始和终止状态一样的，java中将就绪和运行合并为可运行，将阻塞细分为阻塞、等待和超时等待。值得注意的是，操作系统中一部分阻塞，在java中认为是可运行状态，例如IO阻塞。

Integer_Double
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java子线程断点中断不了_多线程超时中断
weixin_30022703的博客
02-24 611
在Java的多线程环境下，如果主线程最多等待子线程执行指定时间就要返回，保证不会因为执行时间过长而长时间没有响应。一般有这么几种途径，线程本身中断，线程池超时中断，计数器等等，有如下几种方式:Thread.join()守护线程线程池+FutureTaskCountDownLatch.await()上面列出的这几种方案，都带了超时退出机制，下面我们来对比一下这几种方案线程joinjoin()是Thr...
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
Java并发编程
qq_52163230的博客
01-21 861
并发/并行 并发 是在某一个时间段内，依次做好几件事情，多个线程访问共享资源 单核cpu就不会出现问题 硬件cpu的功能逐渐强大，已经发展为多核，可以同时执行多个线程，就有可能多个线程同时访问同一个共享数据（秒杀抢购） 并发变成就是要让在多核，多线程下，也只能一次只有一个线程对共享资源访问 并行 多件事情在同一个时刻同事发生 多线程 多线程优点 多线程技术使程序的响应速度更快 ,可以在进行其它工作的同时一直处于活动状态,程序性能得到提升 性能提升的本质 就是榨取硬件的剩余价值(硬件利用率) 多线程带来的
java高并发编程_2.43 JAVA的高并发编程
weixin_39675679的博客
02-22 106
3.03 JAVA的高并发编程一、多线程的基本知识1.1进程与线程的介绍(上个博客中已经详细介绍进程和线程)程序运行时在内存中分配自己独立的运行空间，就是进程线程：它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。进程是负责整个程序的运行，而线程是程序中具体的某个独立功能的运行。一个进程中至少应该有一个线程。1.2多线程的介绍在多任务，多用户的系统中。每天都会产生许多进程。多线程：在一个...
Java并发之AtomicInteger
moni_mm的博客
04-25 802
AtomicInteger AtomicInteger 是一个支持原子操作的 Integer 类， 保证对AtomicInteger类型变量的增加和减少操作是原子性 继承自Number，实现Serializable接口 源码： private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final...
Java并发基础知识
vae260772的专栏
05-22 211
Java并发基础知识
Java并发编程学习笔记
04-11
7、并发工具类CountDownLatch 、CyclicBarrier和Semaphore底层实现原理 8、线程池原理和如何使用线程池 9、ThreadLocal 为什么会内存泄漏 10、Volatile底层实现原理 11、AQS源码分析 12、CAS原理分析和使用场景 13、...
Java并发编程总结——慎用CAS详解
09-02
下面小编就为大家带来一篇Java并发编程总结——慎用CAS详解。小编觉得挺不错的， 现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java 并发编程学习笔记之Synchronized简介
09-02
虽然多线程编程极大地提高了效率，但是也会带来一定的隐患。比如说两个线程同时往一个数据库表中插入不重复的数据，就可能会导致数据库中插入了相同的数据。今天我们就来一起讨论下线程安全问题，以及Java中提供了...
java的int类型线程安全
Oversdownload的博客
07-12 4692
本文转载自：http://blog.csdn.net/xiaoyezi1001/article/details/25504935 一、测试int为线程不安全 在Java中，高并发/多线程情况下，int的自增自减操作都不是线程安全的，使用AtomicInteger可以保证。 [java] view plain copy package 
java 原子类能做什么_死磕 java原子类之AtomicInteger源码分析
weixin_36294852的博客
02-16 85
(手机横屏看源码更方便)问题(1)什么是原子操作？(2)原子操作和数据库的ACID有啥关系？(3)AtomicInteger是怎么实现原子操作的？(4)AtomicInteger是有什么缺点？简介AtomicInteger是java并发包下面提供的原子类，主要操作的是int类型的整型，通过调用底层Unsafe的CAS等方法实现原子操作。还记得Unsafe吗？点击链接直达【死磕 java魔法类之Un...
Java并发AtomicInteger类
evilcry2012的专栏
11-02 148
Java并发AtomicInteger类 ← Java并发条件接口 Java并发AtomicLong类 → java.util.concurrent.atomic.AtomicInteger类提供对基本int值的操作，该值可以以原子方式读取和写入，并且还包含高级的原子操作。AtomicInteger支持底层int变量的原子操作。它具有读取和写入易失性变量的方法。也就是说，一个集合与之后的任何一...
JAVA UNTILS 适用于高并发的int数据自增
weixin_42605169的博客
08-06 486
自增组件 // 自增加组件 适用于高并发 public final int getAndIncrement() { int current; int next; do { current = this.atomicInteger.get(); next = current >= 2147483647 ? 0 : current + 1; } while (!this.atomicInteger.compareAndSet(current,
java并发
lhhhwudi的博客
05-18 322
一.java语言特性 1、跨平台/可移植性 这是Java的核心优势。Java在设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。 2、安全性 Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。 3、面向对象 面向对象是一种程序设计技术，非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C，使
Java并发知识总结，超详细！（下）
m0_53462955的博客
09-13 54
接着来~ 原子类 基本类型原子类 使用原子的方式更新基本类型 AtomicInteger：整型原子类 AtomicLong：长整型原子类 AtomicBoolean ：布尔型原子类 AtomicInteger 类常用的方法： public final int get() //获取当前的值public final int getAndSet(int newValue)//获取当前的值，并设置新的值public final int getAndIncrement()//获取当前的值，并自增public fina
Java 并发（多线程）超详细
qq_42689380的博客
06-27 5928
超级详细解析了 Java 多线程的应用等
java并发编程学习六——乐观锁CAS
yx444535180的专栏
09-22 606
CAS必须借助volatile才能读到共享变量的最新值，从而完成【比较-交换】的效果，来看看AtomicInteger的源码，其中初始值value就是用volatile修饰的。原子累加器，指的是累加操作是原子的，java8之前只能使用原子整数类的incrementAndGet方法，java8新增了LongAdder（并发大神狗哥，Doug Lea编写），专门用于累加操作，效率提升5倍。，当竞争激烈的时候，累加分散到多个cell减少失败重试，最后将结果汇总，最终减少竞争提高效率。给withdraw加锁即可。
java中wait()方法和sleep()方法的区别
勇气与行动
11-19 256
public class Test { public static void main(String[] args) { final Object obj = new Object(); Thread t1 = new Thread(new Runnable() { public void run() { ...
java并发编程学习二——synchronized
yx444535180的专栏
08-18 216
每个java对象都可以关联一个Monitor对象，当对象被synchronized(obj)加锁（重量级）之后，对象头中的Mark Word会记录指向Monitor对象的指针，即上图中的ptr_to_heavyweight_monitor。那么什么是轻量级锁呢，轻量级锁是相对于原来使用操作系统互斥量来实现的传统锁而言的，所以才有轻重的区别。下面看下轻量级锁的实现过程。锁膨胀或者叫锁升级，指的是在CAS操作尝试加轻量级锁时失败，说明已经有其他线程加上了轻量级锁（发生了竞争），将轻量级锁变为重量级。......
java并发编程学习笔记
最新发布
08-30
嗨！很高兴回答你关于Java并发编程的问题。...这些只是一些基本的学习笔记和建议，Java并发编程是一个庞大而复杂的领域，需要不断的实践和深入学习才能掌握。希望对你有所帮助！如果你有更具体的问题，欢迎继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值