多线程（二）——线程的基本操作

最新推荐文章于 2024-05-10 21:29:10 发布
最新推荐文章于 2024-05-10 21:29:10 发布
阅读量236 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Julian_1/article/details/78993615
版权

线程的状态转换
http://blog.csdn.net/pcceo1/article/details/52444730
1.停止线程
Thread.stop(),已经被弃用的方法，不推荐使用。

public class ThreadStop implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println("开始");
            Thread.sleep(10000);
            System.out.println("线程睡了10秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadStop());
        //启动线程
        thread.start();
        //停止线程
        thread.stop();
    }

}

这个程序执行的时候在控制台并没有输出什么，说明线程在启动后，还没有开始执行方法体，线程已经被停止了。
尝试在主线程中睡眠2秒钟，再停止线程。

package cn.zengzehao.thread;

public class ThreadStop implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println("开始");
            Thread.sleep(10000);
            System.out.println("线程睡了10秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadStop());
        thread.start();
        try {
        //休眠2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        thread.stop();
    }

}

程序执行后，在控制台输出了“开始”，2秒钟后结束线程。

通过上面的例子，使用Thread.stop()方法停止线程，不管线程的方法体有没有执行完，都会被停止掉，这样子会容易导致数据不一致的问题，比如在一个线程中写入数据，写到一半线程就被停止掉了。

2.线程的中断
线程被中断，并不是真正去中断线程，而是给线程设置了一个标志位，在线程执行的时候可以检查线程是否被设置了中断。

public void interrupt() // 中断线程
public boolean isInterrupted() // 判断是否被中断
public static boolean interrupted() // 判断是否被中断，并清除当前中断状态

直接看程序吧

package cn.zengzehao.thread;

public class ThreadInterrupted implements Runnable{
    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadInterrupted());
        thread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        thread.interrupt();
        //thread.stop();
    }
    @Override
    public void run() {
        for(;;){
            System.out.println("线程开始执行");
            System.out.println("line22"+Thread.currentThread().isInterrupted());
            if(Thread.currentThread().isInterrupted()){
                System.out.println("线程已经被中断");
                break;
            }
            long sum = 0;
            for(long i=0;i<100000;i++){
                sum+=i;
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                System.out.println("line37"+Thread.currentThread().isInterrupted());
                //设置中断状态，抛出异常后会清除中断标记位
                Thread.currentThread().interrupt();
                System.out.println("line39"+Thread.currentThread().isInterrupted());
            }
            System.out.println(sum);
        }
    }

}

执行程序，如果调用interrupted()，线程会把方法体剩下的执行完，如果是调用stop()，线程会直接就结束。stop()方法太暴力了，不推荐使用。

3.线程的挂起和继续执行线程
– suspend()不会释放锁
– 如果加锁发生在resume()之前 ，则死锁发生

4.等待线程的结束 jion()
在多线程中，经常需要等待其他线程执行完，再进行下面的操作，这个时候就需要用到jion()

package cn.zengzehao.thread;

public class ThreadJion implements Runnable{
    public volatile static int i =0;
    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadJion());
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main方法"+i);
    }

    @Override
    public void run() {
        for(i=0;i<1000000;i++);
        System.out.println("方法内："+i);
    }
}

如果不使用jion()，运行结果是

main方法0
方法内：1000000

使用jion()，运行结果是

main方法1000000
方法内：1000000

5.线程的谦让 yield()
一个调用yield()方法的线程告诉虚拟机它乐意让其他线程占用自己的位置。

6.线程等待wait()
7.线程的唤醒notify()和notifyAll()

package cn.zengzehao.thread;

public class ThreadWaitAndNotify {
    final static Object object= new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        t1.start();
        t2.start();
    }
    static class T1 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T1线程开始");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("T1线程结束");
            }

        }

    }
    static class T2 implements Runnable{

        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T2线程开始");
                object.notify();
                System.out.println("T2线程结束");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

}

notify()会随机唤醒一个在等待的线程。
notifyAll()会唤醒全部的线程。

package cn.zengzehao.thread;

public class ThreadWaitAndNotify {
    final static Object object= new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        Thread t3 = new Thread(new T3());
        Thread t4 = new Thread(new T4());
        t1.start();
        t3.start();
        t4.start();
        //休眠100毫秒，为了唤醒线程可以在其他线程都已经启动
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t2.start();
    }
    static class T1 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T1线程开始");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("T1线程结束");
            }

        }

    }
    static class T3 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T3线程开始");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("T3线程结束");
            }

        }

    }

    static class T4 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T4线程开始");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("T4线程结束");
            }

        }

    }
    static class T2 implements Runnable{

        @Override
        public void run() {
            synchronized (object) {
                System.out.println("T2线程开始");
                object.notify();
                System.out.println("T2线程结束");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

}
曾泽浩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
iOS多线程开发——NSThread浅析
09-02
首先，初始化并启动一个线程是NSThread的基本操作。在`viewWillAppear:`方法中，我们可以创建一个新的线程实例，通过`initWithTarget:selector:object:`方法指定线程的目标对象、执行的 selector（方法）以及传递的...
多线程 +高并发 4
qq_39890679的博客
10-14 88
ThreadLocal 源码 set Thread currentThread map(Thread ,person) 设到了当前线程的map ThreadLocal 用途 -声明式事务 保证同一个Connection 强 软 弱 虚 引用 vector hashtable 基本不用 map hashMap treeMap （红黑树 排好序的） ...
两个线程，一个线程输出1，一个线程输出2，循环输出
专注
06-12 7521
/** * 两个线程，一个线程输出1，一个线程输出2, * * @author ffr@cnic.cn * */ public class SleepAndWaitThread2 { public static void main(String[] args) { OneThread one = new OneThread(); TwoThread two = new Tw
多线程编程——Linux操作系统
m0_74058637的博客
05-10 850
本文简单分享了一下线程的理解和一些线程编程常用的接口函数的操作，希望可以对大家有所帮助。
操作系统——多线程
追寻上飞的博客
05-14 4370
1，什么是线程（Thread） 线程是处理代码的执行流，有着自己的程序计数器，用来追踪下一次执行的指令，系统寄存器持有它的变量，栈包含了它的执行历史。 线程间可进行数据共享。当一个线程改变了内存，其他线程亦可以看到。 线程也叫做轻量级进程。线程基于并行工作提高应用程序的性能。线程是一种提高操作系统性能的软件方法，但是其开销小于多进程。 每一个线程都存在一个特定的进程中。没有任何一个线程可存在于一...
Java多线程——基本概念
热门推荐
hebtu666
10-23 1万+
线程和多线程 程序：是一段静态的代码，是应用软件执行的蓝本 进程：是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程 线程：是比进程更小的执行单位。进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念 主线程：（每个Java程序都有一个...
操作系统（多线程）
2303_77275067的博客
03-15 770
多线程编程、多核、操作系统
JAVA多线程——守护线程
万里顾一程的博客
09-01 1824
JAVA多线程——守护线程 线程分为用户线程（如main线程）和守护线程 虚拟机必须确保用户线程执行完成 虚拟机不用等待守护线程执行完毕 守护线程的作用：后台记录操作，日志，监控内存，垃圾回收，等待机制等 package com.peng.demon04; //测试守护线程 public class TestDaemon { public static void main(String[] args) { Gad gad = new Gad();
VS+QT多线程实现——run和moveToThread
Jack1009HF的博客
09-14 4500
VS+QT多线程实现——run和moveToThread实现方法及特性run代码实现moveToThread代码实现讨论工程源码 写在前头：最近学习多线程开发，以小白的视角写一些学习心得。也欢迎各位朋友勘误补充。 实现方法及特性 run ——继承QThread的run函数，通过重写run()方法，实现任务功能。 使用run方便理解，简单的任务流程可以封装在run里面。 run 是线程的入口，run的开始和结束意味着线程的开始和结束。 多线程访问变量或处理事务要考虑加锁。（目前还未涉及加锁，不展开讨论）
JAVA多线程——共享变量
WenbinYao&YouweiHu
11-12 9514
【转载】Java多线程编程：变量共享分析（Thread） 原博客网址：https://www.cnblogs.com/xudong-bupt/archive/2013/05/22/3087864.html 今天看到java的多线程，感到十分激动，之前就在python中使用过多线程和多进程，十分强大，但是对于其中的理论却并不是十分理解，因此希望借此机会能够...
Java多线程——交替输出
weixin_42275702的博客
01-17 7863
设置两个线程交替输出"1 2 1 2 1 2…" 1. 定义一个全局锁对象 为了保证两个线程使用的一定是同一个锁，我们创建一个对象作为静态属性放到一个类中， 这个对象就用来充当锁 2. 定义一个线程输出1，另外一个线程输出2 该线程输出十次 1，使用 MyLock.o 作为锁，每输出一个 1 就唤醒另一个线程，然后自己休眠并释放锁。 public class ThreadForNum1 extends Thread { @Override public void run() {
Java多线程系列——-多线程的风险问题
01-08
多线程中的饥饿，其意思是，线程的调度如果只考虑线程优先级的话，那么在线程执行队列中，如果有高优先级的线程插入，该线程就会插入到低优先级线程的前方，这样可能导致低优先级的线程无法执行，最终造成低优先级...
多线程编程——实战篇
05-03
多线程编程——实战篇
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
07-08
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
2003-2023年飞机航线信息数据.xlsx
07-08
2003-2023年飞机航线信息数据 1、时间：2003-2023年 2、来源：高铁航线数据库（Chinese High-speed Rail and Airline Database，CRAD） 3、指标：起点城市、起点城市所属地级市、起点城市所属省份、起点机场、终点城市、终点城市所属地级市、终点城市所属省份、终点机场、航空公司、更新日期、航班、出发时间、到达时间、准点率、班次_周一、班次_周二、班次_周三、班次_周四、班次_周五、班次_周六、班次_周日
Xilinx Vitis 2020工程源目录修改
07-08
Xilinx Vitis可以做standalone程序开发,不过其工程中使用的路径为绝对路径。工程更换位置后编译将会显示错误。例如：源目录为D:/work,复制到同事电脑上放到C:/work(同事电脑只有一个C盘)。利用Vitis打开工程编译会有一堆错误，提示文件找不到。本脚本用来解决该问题。
1000__gpt_4_prompts.md
07-08
1000__gpt_4_prompts
电子行业点评：算力需求持续提升，景嘉微强势入局.pdf
最新发布
07-08
电子元件 电子行业 行业分析 数据分析 数据报告 行业报告
C++多线程编程——线程的挂起、唤醒与终止
05-25
在 C++ 中，我们可以使用线程库来实现多线程编程。线程的挂起、唤醒与终止是多线程编程中非常重要的一部分。 线程的挂起也称为线程的休眠，它可以让线程停止运行一段时间，等待某个条件满足后再继续运行。在 C++ 中，我们可以使用 std::this_thread::sleep_for() 函数来实现线程的挂起，该函数可以让当前线程挂起一段时间，例如： ```cpp #include <chrono> #include <thread> int main() { // 挂起当前线程 1 秒钟 std::this_thread::sleep_for(std::chrono::seconds(1)); return 0; } ``` 线程的唤醒可以通过条件变量来实现，条件变量是一种同步机制，用于在线程之间传递信号。在 C++ 中，我们可以使用 std::condition_variable 类来创建条件变量，然后使用 wait() 函数来挂起线程等待条件变量的信号，使用 notify_one() 函数来唤醒一个等待条件变量的线程，例如： ```cpp #include <condition_variable> #include <mutex> #include <thread> std::condition_variable cv; std::mutex mtx; bool ready = false; void worker_thread() { // 等待条件变量的信号 std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, [](){ return ready; }); // 条件满足后继续执行 // ... } int main() { // 唤醒等待条件变量的线程 { std::lock_guard<std::mutex> lock(mtx); ready = true; } cv.notify_one(); return 0; } ``` 线程的终止可以使用 std::thread::join() 函数来实现，该函数可以让当前线程等待另一个线程执行完成后再继续执行，例如： ```cpp #include <thread> void worker_thread() { // ... } int main() { std::thread t(worker_thread); // 等待 worker_thread 执行完成 t.join(); return 0; } ``` 另外，线程的终止还可以使用 std::thread::detach() 函数来实现，该函数可以让当前线程与创建的线程分离，使得两个线程可以独立运行，例如： ```cpp #include <thread> void worker_thread() { // ... } int main() { std::thread t(worker_thread); // 分离线程，使得两个线程可以独立运行 t.detach(); return 0; } ``` 需要注意的是，分离线程后，主线程不能再使用 join() 函数等待子线程执行完成，否则会导致程序崩溃。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值