java Thread的探索（一）

最新推荐文章于 2024-01-14 01:33:38 发布
最新推荐文章于 2024-01-14 01:33:38 发布
阅读量516 收藏
点赞数 1
文章标签： Thread 线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37050608/article/details/77286269
版权

一、总结一下Thread的方法

1.Thread的构造函数

1.1 Thread():无参构造

1.2 Thread(Runnable target)

1.3 Thread(ThreadGroup group ,Runnabletarget)

1.4 Thread(String name)

1.5 Thread(Runnable target,String name)

1.6 Thread(ThreadGroup group, Runnabletarget,String name)

1.7 Thread(ThreadGroup group,Runnabletarget,String name,long stactSize)

 参数group:线程组

    target:Runnable对象

    name:线程名

         stactSize:线程所需堆栈大小，如果为零表示忽略

2. Thread的静态方法：

2.1 currentThread():返回对当前执行对象的引用；

2.2 yield():执行yield（）提示当前线程调度器愿意放弃当前所使用的处理器，当然调度器可以忽略这个提示（可以理解为你想让当前线程让步，但是愿不愿意让，具有不确定性）。

2.3 sleep(long millis):当前的线程以指定的毫秒数休眠（暂时停止执行），线程不会失去监视器的所有权（可以理解为不会释放该线程持有的对象锁），sleep(long millis),内部调用了sleep(long millis,int nanos)方法；

2.4 sleep(long millis,int nanos):当前的正在执行的线程以指的毫秒数（ms）加纳秒数(ns)休眠（暂时停止执行），线程不会失去监视器的所有权（1ms=106ns精度很高）；

2.5 interrupted():测试当前线程是否被暂停，此方法清除线程的暂停状态。

3.Thread的非静态方法

3.1 start()：线程执行方法，重复执行将会thrownew IllegalArgumentException,这是一个synchronized方法

3.2 interrupt():暂停该线程

3.3 isInterrupted():判断线程是否为暂停状态，线程的状态不受此方法的影响；

3.4 isAlive():判断线程是否活着的

3.5 setPriority(int newPriority):设置线程的优先级，默认优先级为5，最小为1，最大为10；

3.6 getPriority():获取线程的优先级；

3.7 setName(String name):设置线程名；

3.8 getName():获取线程名；

3.9 getThreadGroup():获取线程组

3.10 activeCount():返回当前线程及其子组线程中活动线程的估计值；

3.11 enumerate(Thread array[]):将当前的线程组及其子组中的每个活动线程复制到指定数组中，并返回放入线组的线程数；

3.12 join(long millis):等待此线程最多mills或者此线程在mills内结束。

  join():等待此线程结束，内部调用的join(0);

join(long mills,int nanos):这个方法内部调用了join(longmills)，只是等待时间为 mills+nanos;

3.13 setDaemon(boolean on):将此线程是否设置为守护线程，此方法必须在start()之前设置，否则报错；

3.14 isDaemon():判断此线程是否为守护线程；

3.15 checkAccess():确认当前线程是否有修改此线程的权限

3.16 getId():返回当前线程的id;

3.17 getState():返回当前线程的状态State.

 二、实际操作

   说一千道一万，不如自己来实际操作一下。首先来测试线程的暂停状态，先来看下一般的异常抛出

代码如下：

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    File file = new File(Environment.getExternalStorageDirectory() + "/abcdef");
                    try {
                        FileInputStream in = new FileInputStream(file);
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
    }empty运行结果
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err: java.io.FileNotFoundException: /storage/emulated/0/abcdef: open failed: ENOENT (No such file or directory)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at libcore.io.IoBridge.open(IoBridge.java:452)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at java.io.FileInputStream.
    
    
     
     (FileInputStream.java:76)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at com.wogu.threaddemo2.MainActivity$1.run(MainActivity.java:26)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at java.lang.Thread.run(Thread.java:818)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err: Caused by: android.system.ErrnoException: open failed: ENOENT (No such file or directory)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at libcore.io.Posix.open(Native Method)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at libcore.io.BlockGuardOs.open(BlockGuardOs.java:186)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err:     at libcore.io.IoBridge.open(IoBridge.java:438)
08-17 11:13:03.425 6531-6573/threaddemo2 W/System.err: 	... 3 more
08-17 11:13:04.466 6531-6573/threaddemo2 W/System.err: java.io.FileNotFoundException: /storage/emulated/0/abcdef: open failed: ENOENT (No such file or directory)
08-17 11:13:04.466 6531-6573/threaddemo2 W/System.err:     at libcore.io.IoBridge.open(IoBridge.java:452)
08-17 11:13:04.466 6531-6573/threaddemo2 W/System.err:     at java.io.FileInputStream.
     
     
      
      (FileInputStream.java:76)
08-17 11:13:04.466 6531-6573/threaddemo2 W/System.err:     at com.wogu.threaddemo2.MainActivity$1.run(MainActivity.java:26)
08-17 11:13:04.466 6531-6573/threaddemo2 W/System.err:     at java.lang.Thread.run(Thread.java:818)

可以看到文件路径不存在，该线程每秒抛出一个FileNotFoundException异常

再看下thread2被暂停后会出现什么结果

empty

    private static final String TAG = "MainActivity";
    private Thread thread1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    Log.i(TAG, "当前线程名:" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }, "thread1");
        thread1.start();
        //建立一个定时器2秒后暂停线程thread1
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                Log.i(TAG, "线程暂停前状态：" + thread1.isInterrupted());
                thread1.interrupt();
                Log.i(TAG, "线程暂停后状态：" + thread1.isInterrupted());
            }
        };
        Timer timer=new Timer("checkThreadState");
        timer.schedule(task,2000);
    }empty测试结果
11:31:21.237 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:22.238 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:22.239 25594-25665/threaddemo2 I/MainActivity: 线程暂停前状态：false
08-17 11:31:22.239 25594-25665/threaddemo2 I/MainActivity: 线程暂停后状态：true
08-17 11:31:22.239 25594-25664/threaddemo2 W/System.err: java.lang.InterruptedException
08-17 11:31:22.241 25594-25664/threaddemo2 W/System.err:     at java.lang.Thread.sleep(Native Method)
08-17 11:31:22.241 25594-25664/threaddemo2 W/System.err:     at java.lang.Thread.sleep(Thread.java:1031)
08-17 11:31:22.241 25594-25664/threaddemo2 W/System.err:     at java.lang.Thread.sleep(Thread.java:985)
08-17 11:31:22.241 25594-25664/threaddemo2 W/System.err:     at com.wogu.threaddemo2.MainActivity$1.run(MainActivity.java:25)
08-17 11:31:22.241 25594-25664/threaddemo2 W/System.err:     at java.lang.Thread.run(Thread.java:818)
08-17 11:31:22.241 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:23.241 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:24.242 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:25.242 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:26.242 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:27.242 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1
08-17 11:31:28.243 25594-25664/threaddemo2 I/MainActivity: 当前线程名:thread1

thread2.isInterrupted()调用此方法后，查看日志后可以看到thread2的确暂停了，但是为什么只抛出一次InterruptedException异常。看了下Thread类，突然发现sleep(long millis,int nanos)调用了Thread.interrupted()方法（查看下），该方法具有清除了thread2线程的暂停状态的作用，所以第二次不会再出现异常。

empty
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("millis < 0: " + millis);
        }
        if (nanos < 0) {
            throw new IllegalArgumentException("nanos < 0: " + nanos);
        }
        if (nanos > 999999) {
            throw new IllegalArgumentException("nanos > 999999: " + nanos);
        }

        // The JLS 3rd edition, section 17.9 says: "...sleep for zero
        // time...need not have observable effects."
        if (millis == 0 && nanos == 0) {
            // ...but we still have to handle being interrupted.
            //此处调用了Thread.interrupted()
            if (Thread.interrupted()) {
              throw new InterruptedException();
            }
            return;
        }

        long start = System.nanoTime();
        long duration = (millis * NANOS_PER_MILLI) + nanos;

        Object lock = currentThread().lock;

        // Wait may return early, so loop until sleep duration passes.
        synchronized (lock) {
            while (true) {
                sleep(lock, millis, nanos);

                long now = System.nanoTime();
                long elapsed = now - start;

                if (elapsed >= duration) {
                    break;
                }

                duration -= elapsed;
                start = now;
                millis = duration / NANOS_PER_MILLI;
                nanos = (int) (duration % NANOS_PER_MILLI);
            }
        }
    }

  再来看看join这个重载方法，join这个重载方法，归根结底还是join(long millis)。Join(long millis)内部是一个synchronized（lock）{},而lock是Object对象，这就意味着Activity中所有其他线程都将暂停。直到获得Object对象锁的线程在设定的时间内已经结束，或者超过设定的时间（换句话来说就是等到该线程释放了Object对象锁）。代码如下：

empty
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TestThread testThread=new TestThread();
        Thread thread2=new Thread(testThread,"Thread2");
        thread2.start();
        //主线程每秒打印一次
        for (int i = 0; i < 5; i++) {
            Log.i(TAG, "当前线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
      
    }
    private class TestThread implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                Log.i(TAG, "当前线程名:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }empty
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TestThread testThread=new TestThread();
        Thread thread2=new Thread(testThread,"Thread2");
        thread2.start();
        //调用thread2 join()
        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程每秒打印一次
        for (int i = 0; i < 5; i++) {
            Log.i(TAG, "当前线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
    private class TestThread implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                Log.i(TAG, "当前线程名:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }

未使用Thread2.join()运行日志如下，可以看到主线程和子线程交替运行


当前线程名:main
当前线程名:Thread2
当前线程名:main
当前线程名:Thread2
当前线程名:main
当前线程名:Thread2
当前线程名:main
当前线程名:Thread2
当前线程名:main
当前线程名:Thread2

在看下thread2使用join（），运行结果如何

当前线程名:Thread2
当前线程名:Thread2
当前线程名:Thread2
当前线程名:Thread2
当前线程名:Thread2
当前线程名:main
当前线程名:main
当前线程名:main
当前线程名:main
当前线程名:main

通过日志可以看到，只有等thread2运行完了，主线程才开始运行.在看看使用join（2000）看下运行日志如何

08-17 13:43:47.584 31157-31231/com.threaddemo2 I/MainActivity: 当前线程名:Thread2
08-17 13:43:48.584 31157-31231/com.threaddemo2 I/MainActivity: 当前线程名:Thread2
08-17 13:43:49.584 31157-31157/com.threaddemo2 I/MainActivity: 当前线程名:main
08-17 13:43:49.585 31157-31231/com.threaddemo2 I/MainActivity: 当前线程名:Thread2
08-17 13:43:50.585 31157-31231/com.threaddemo2 I/MainActivity: 当前线程名:Thread2
08-17 13:43:50.585 31157-31157/com.threaddemo2 I/MainActivity: 当前线程名:main
08-17 13:43:51.585 31157-31157/com.threaddemo2 I/MainActivity: 当前线程名:main
08-17 13:43:51.585 31157-31231/com.threaddemo2 I/MainActivity: 当前线程名:Thread2
08-17 13:43:52.585 31157-31157/com.threaddemo2 I/MainActivity: 当前线程名:main
08-17 13:43:53.586 31157-31157/com.threaddemo2 I/MainActivity: 当前线程名:main

因为thread2是每秒打印一次日志，thread2.join（2000）了2秒，所以打印2次后，Object对象锁释放了。其实这种现象很好解释，因为join（）内部的同步方法更深层次调用的是lock.wait(long millis)方法。再来看看Object对象的wait(long millis),说的简单点就是mills毫秒后释放Object对象锁。（未完待续）

程_gang
关注
java thread
06-14
本学习教程旨在帮助初学者掌握Java线程的基础知识，并进一步探索线程同步的概念。 首先，线程的基本概念是理解线程模型的关键。在Java中，一个进程可以有多个线程，每个线程都有自己的程序计数器、虚拟机栈、本地...
Java多线程编程详解
小人物的专栏 *^_^*
10-12 813
一：理解多线程多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。 线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个C
Java多线程初识
weixin_43188446的博客
05-15 969
初识多线程 线程是操作系统中CPU运行调度的最小单位，一个进程包含多个线程，每个线程可以执行不同的任务。并发执行可以让程序运行得更快 多线程下的并行、并发 并行 指同一个的时间中，同时执行的线程(两个或以上)。 例如：一台机器需要花10分钟才可以执行完成的任务，两台机器可以拆分任务那么就只需要各5分钟在同一时刻就可以完成，这就代表并行。 注：一个机器可以理解为一个单核的CPU，那么并行就需要多核CPU 并发 多个线程同时请求执行任务，但是在这段时间内就只可以执行一个线程，然而CPU拥有很快的速度，
Java中断异常 InterruptedException 的正确处理方式
weixin_33738578的博客
12-09 5191
你看到这篇文件可能是因为你已经调用了一个抛出 InterruptedException 异常的方法，并且需要以某种方式处理它。 首先，需要了解为一个方法为啥会 throws InterruptedException, 是这个方法抛出中断异常作为方法签名的一部分以及调用正在调用的方法的可能结果。因此，首先要接受一个事实，Interrupte...
Java线程之 InterruptedException 异常
热门推荐
Derekjiang的笔记簿
11-21 6万+
 当一个方法后面声明可能会抛出InterruptedException 异常时，说明该方法是可能会花一点时间，但是可以取消的方法。 抛InterruptedException的代表方法有：1. java.lang.Object 类的 wait 方法2. java.lang.Thread 类的 sleep 方法3. java.lang.Thread 类的 join 方法 
java.lang.InterruptedException中断（interrupt）没有执行
weixin_45969142的博客
08-02 4756
报错的执行代码如下： // 使用匿名内部类形式初始化Thread实例子 threadA = new Thread(new Runnable() { public void run() { // 重写run()方法 for(int i =0 ; i <= 100 ; i ++) { progressBar.setValue(i); if(i == 50) { threadA.interrupt(); } try {
Java一
02-13
【Java一】——深入探索Java编程基础与进阶 Java作为一种广泛应用的面向对象的编程语言，自1995年发布以来，一直在软件开发领域占据着重要的地位。它以其跨平台性、安全性以及稳定性赢得了全球程序员的喜爱。"Java...
jexp:探索Java相关技术
05-14
- 线程基础：Java提供了Thread类和Runnable接口来创建和管理线程。 - 同步机制：synchronized关键字、Lock接口（如ReentrantLock）用于保证线程安全，防止数据竞争。 - 线程池：ExecutorService和...
Java探索之Thread+IO文件的加密解密代码实例
08-29
本文将深入探讨如何结合Java的线程（Thread）和输入/输出流（IO流）实现文件的加密与解密。通过创建自定义线程类，我们可以实现多线程处理，提高文件操作的效率。 首先，我们看到两个类`enCodeFileThread`和`...
一篇不错的讲解Java异常的文章(转载）
秃了也弱了
02-22 1952
六种异常处理的陋习 你觉得自己是一个Java专家吗？是否肯定自己已经全面掌握了Java的异常处理机制？在下面这段代码中，你能够迅速找出异常处理的六个问题吗？ 1 OutputStreamWriter out = ... 2 java.sql.Connection conn = ... 3 try { // ⑸ 4 　Statement stat = conn.createStatement(); 5 　ResultSet rs = stat.executeQu...
Java处理InterruptedException异常的理论与实践
09-01
在使用Java的过程中，有个情景或许很多人见过，您在编写一个测试程序，程序需要暂停一段时间，于是调用 Thread.sleep()。但是编译器或 IDE 报错说没有处理检查到的 InterruptedException。InterruptedException 是什么呢，为什么必须处理它？下面跟着小编一起来看看。
java.lang.InterruptedException: sleep interrupted
wusb5的博客
01-12 4077
sleep interrupted
at java.lang.Thread.run(Thread.java:724) Caused by: java.lang.UnsupportedClassVersionError: com/snai
k_1075659958的博客
04-25 1万+
运行项目报错  可能是jar或者是Tomcat的版本问题  改一下就可以了
已解决java.lang.InterruptedException异常的正确解决方法，亲测有效！！！
最新发布
小明的Java问道之路
01-14 7885
已解决java.lang.InterruptedException异常的正确解决方法，亲测有效！！！
java.lang.thread.run_Dev Server starting at java.lang.Thread.run(Thread.java:745
weixin_35772723的博客
02-25 1404
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Executing [C:\Program Files (x86)\AppInventor_2016OfflineEdition\JDK\jre\bin\java, -javaagent:C:\Program Files (x86)\AppInventor_2016OfflineEdition\AppEngine\lib\agent\appengine-...
Java处理InterruptedException
Xiaowo
06-14 3万+
机制 在Java中，一个线程是不能终止另一个线程的，除非那个线程自己想退出，或者JVM退出了。 比如： Thread loop = new Thread( new Runnable() { @Override public void run() { while (true) { } } } ); loop.start(); 这个线...
Unhandled exception: java.lang.InterruptedException 解决方法
ChenMiao0924的博客
07-29 2万+
在学习java中，遇到某些函数时，按照一般的写法调用时，会出现上述报错， System.out.println(new Date( )); Thread.sleep(1000); System.out.println(new Date( )); 报错信息如下： 后来，查了下资料，发现原因是：某些函数自带有异常， 所以你使用的时候，也需要处理下异常，正确的代码为： try { System.out.println(new Date( ));
java sleep 异常_java – 为什么需要处理Thread.sleep()的异常？
weixin_35886660的博客
02-19 2352
如果以一种方式声明方法可以抛出已检查的异常(异常不是RuntimeException的子类),调用它的代码必须在try-catch块中调用它,或者调用方法必须声明抛出它.public static void sleep(long millis) throws InterruptedException;为什么Thread.sleep()以这种方式声明？因为如果Thread正在睡眠,线程可能被中断,例...
at java.lang.thread.run unknown source_项目启动不了，启动报错找不到原因
weixin_31001739的博客
03-02 3857
java.lang.NoClassDefFoundError: CLOBat java.lang.Class.getDeclaredMethods0(Native Method)at java.lang.Class.privateGetDeclaredMethods(Unknown Source)at java.lang.Class.privateGetPublicMethods(Unknown ...
Java并发编程：探索ThreadGroup与线程管理
"Java并发编程中的线程组是通过ThreadGroup类实现的，它允许我们对线程进行分组管理，形成一个树形结构。尽管《EffectiveJava》建议避免使用ThreadGroup，转而推荐使用Executor框架，但在某些场景下，线程组仍然有其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值