线程基础理论

最新推荐文章于 2021-11-09 10:27:02 发布
最新推荐文章于 2021-11-09 10:27:02 发布
阅读量350 收藏
点赞数
分类专栏： 并发编程 文章标签： 多线程 基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Munger6/article/details/98475886
版权

1、创建线程：

       Thread类、Runable接口、Callable带返回值的接口；在使用的时候尽量考虑使用接口实现，因为我们java是单继承多实现；

public class CreateThreadDemo {

     //为何都是使用start()方法 而不是run()方法；因为start方法在创建线程，
     //   run()则是直接调用该方法并没有创建多线程 
     public static void main(String[] args) {
         //1.继承Thread
         Thread thread = new Thread() {
             @Override
             public void run() {
                 System.out.println("继承Thread");
                 super.run();
             }
         };
         thread.start();

         //2.实现runable接口
         Thread thread1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println("实现runable接口");
             }
         });
         thread1.start();

         //3.实现callable接口
         ExecutorService service = Executors.newSingleThreadExecutor();
         Future<String> future = service.submit(new Callable() {
             @Override
             public String call() throws Exception {
                 return "通过实现Callable接口";
             }
         });
         try {
             String result = future.get();
             System.out.println(result);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

 

2、线程的状态：

基本概念：

       NEW：调用start()初始状态

       RUNNABLE：运行状态，将就绪和运行称作运行中

       BLOCKED：阻塞，表示线程阻塞于锁

       WAITING：等待状态表示线程进入等待状态，知道通知或中断

       TIMED_WAITING：超时等待状态，在指定时间内自行返回

       TERMINATED：终止状态，线程已执行完毕

线程状态案例：

package com.hezm.thread.day1.lifecycle;


import java.util.concurrent.TimeUnit;

public class ThreadStatusDemo {

    /***
     * 查看线程运行状态方法：
     *          1、Recompile  或者run 运行一次程序
     *          2、找到目录target-classes-com....下对应文件ThreadStatusDemo.class 右键 Open in Terminal
     *          3、在console中运行jps  查看当前运行java进程
     *          4、运行jstack 4044     jstack  进程号  查看线程堆栈日志
     *              blocked_thread_2   状态为  TIMED_WAITING
     *              blocked_thread_1   状态为  BLOCKED    锁被线程2抢占，线程1阻塞
     *              wating_thread   状态为  WAITING
     *              time_wating_thread   状态为  TIMED_WAITING
     * @param args
     */
    public static void main(String[] args) {

        new Thread(()->{
            try {
                while (true){
                    TimeUnit.SECONDS.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"time_wating_thread").start();


        new Thread(()->{
            try {
                while (true){
                    synchronized (ThreadStatusDemo.class){
                        //获得锁，然后wait；
                        ThreadStatusDemo.class.wait();
                    }
                }
                //InterruptedException线程可能异常就中断了；
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"waiting_Thread").start();

        new Thread(new BlockedDemo(),"blocked_thread_1").start();
        new Thread(new BlockedDemo(),"blocked_thread_2").start();
    }

    //阻塞线程
    static class BlockedDemo extends Thread{
        @Override
        public void run() {
            try {
                while (true){
                    synchronized (ThreadStatusDemo.class){
                        TimeUnit.SECONDS.sleep(100);  
                    }
                }
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

线程状态转换图：

 

 

3、线程基本操作：

     join()实现顺序执行：

package com.hezm.thread.day1.safe;

/**
 * 实现线程的顺序执行
 */
public class JoinRule {
    static int x = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            x=100;
        });
        t1.start();
        t1.join();
        //值一定为100，在join之后对线程内的操作可见；
        System.out.println(x);
        Thread t2 = new Thread(()->{
            System.out.println("t1");
        });
        Thread t3 = new Thread(()->{
            System.out.println("t2");
        });
        Thread t4 = new Thread(()->{
            System.out.println("t3");
        });
        t2.start();
        t2.join();   // 通过wait方法实现  直到线程被销毁的时候释放；  实现主线程阻塞等待线程执行完成；

        t3.start();
        t3.join();

        t4.start();
        t4.join();


    }
}

 

     线程的优雅中断1：interrupted，实现原理：通过一个volatile修饰的标志位来标识是否中断线程；

package com.hezm.thread.day1.stop;


import java.util.concurrent.TimeUnit;

public class InterruptThread {

    private static int i = 0;

    /***
     * 线程的优雅中断；
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            //判断是否标记要中断线程： 默认值为false，true表示中断；
            while (!Thread.currentThread().isInterrupted()){    
                i++;
                System.out.println(i);
            }
        });

        thread.start();
        System.out.println(thread.isInterrupted());
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();  //将 isInterrupted 的值设置为true,标记要进行中断；
        System.out.println(thread.isInterrupted());
        //源码：    private native void interrupt0();
        //jvm方法：  os :: interrupt(Thread thread)
        //     有很多os，针对不同的操作系统有不同的实现；
    }
}

 

    线程复位：

package com.hezm.thread.day1.stop;


import java.util.concurrent.TimeUnit;

/**
 * 线程复位：对中断的线程进行中断复位
 *      方式1：Thread.interrupted()
 *      方式2：InterruptedException；   复位的原因：复位标识我得到外界要求中断的信号，然后自己择机中断；
 *      3，为什么所有和阻塞相关的方法都有 InterruptedException 异常？
 *            wait 和 sleep等在阻塞中间可能外部会强行关闭线程，当关闭线程的时候就会抛出 InterruptedException 异常
 *            抛出异常以后就可以进行响应的处理；因此强行关闭，线程并没有死去；
 */
public class ThreadResetDemo {

    //方式1： Thread.currentThread().isInterrupted()
//    public static void main(String[] args) throws InterruptedException {
//        Thread thread = new Thread(()->{
//            //是否为中断？  默认值为false；
//            while (true){
//                if(Thread.currentThread().isInterrupted()){
//                    System.out.println("before:"+Thread.currentThread().isInterrupted());
//                    Thread.interrupted();   //复位回到初始状态
//                    System.out.println("after:"+Thread.currentThread().isInterrupted());
//                }
//            }
//        });
//
//        thread.start();
//        TimeUnit.SECONDS.sleep(1);
//        thread.interrupt();
//    }




    //方式2：InterruptedException，异常的复位
    /**
     * 使用场景：在异常被抓住的时候，我们可以对线程进一步处理；是抛出异常，中断程序或者其他都可以；就
     */
    private static  int i = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            //是否为中断？  默认值为false；
            while (!Thread.currentThread().isInterrupted()){
                try {
                    System.out.println(System.currentTimeMillis() + "in Thread");
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    //中断一个处于阻塞状态的线程   join/wait/queue.take；  首先进行复位，然后中断线程；
                    System.out.println(System.currentTimeMillis() + "==c==" + Thread.currentThread().isInterrupted());
                    e.printStackTrace();
                }
                i++;
            }
            System.out.println("i:" + i);
        });
        //  即使主线程启动了TimeUnit.SECONDS.sleep(1)  也会导致thread的 InterruptedException 异常；
        //  因此，休眠前需要将状态进行修改（thread.interrupt()）才能体现 InterruptedException 对状态的的修改；
        thread.start();
        System.out.println(System.currentTimeMillis() + "==a==" + thread.isInterrupted());
        thread.interrupt();
        System.out.println(System.currentTimeMillis() + "==b==" + thread.isInterrupted());
        TimeUnit.SECONDS.sleep(1);
    }


}

 

 

 

可重入读写锁的使用：

package com.hezm.thread.day1.theory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**可重入读写锁*/
public class ReentrantReadWriteLockDemo {
    static ReentrantReadWriteLock writeLock = new ReentrantReadWriteLock();    //可重入读写锁；读不需要加锁。
    static Map<String, Object> cacheMap = new HashMap<>();

    static Lock read = writeLock.readLock();
    static Lock write = writeLock.writeLock();

    public static void main(String[] args) {
        /**
         * 适用于：读多写少的场景：
         * 读->读可以共享   // Thread2：在get的时候，  Thread1：线程在get的时候不会阻塞，可共享数据；
         * 读->写互斥   // Thread2：在put的时候，  Thread1：线程在get的时候会阻塞，等待写完才读，读到最新数据；
         * 写->写互斥  // Thread2：在put的时候，  Thread1：线程在put的时候会阻塞，等待写完才put；
         */
        put("zhangsan","23岁");
        get("zhangsan");
    }

    //Thread1：读锁：读的时候获取最新数据
    public static final Object get(String key){
        System.out.println("begin read deta:" + key);
        read.lock();
        try {
            return cacheMap.get(key);
        } finally {
            read.unlock();   //防止死锁，一直不释放锁
        }
    }

    //Thread2：写锁：写操作对读可见
    public static final Object put(String key, Object value){
        write.lock();
        try {
            System.out.println("begin write deta:" + key + "value" + value);
            return cacheMap.put(key,value);
        } finally {
            write.unlock();   //防止死锁，一直不释放锁
        }
    }
}

 

Munger6
关注
专栏目录
C#多线程——Thread睡眠、中断、合并、暂停与恢复、终止
AronZhang的博客
06-02 2万+
C#多线程的一些操作，Sleep、Join、Interupt、暂停与恢复（重点）、终止
[VB.NET]多线程——取消任务
VB.NET学习网-VB.NET实例、VB.NET教程、VB.NET源码下载
11-30 1305
多线程的一个优点是，应用程序的用户界面部分始终可以作出响应，即使其他线程正在执行任务。同步事件和作为标志的字段通常用于通知其他线程停止。以下示例使用同步事件来取消任务。要使用本示例，请在项目中添加以下模块。要启动线程，请调用 StartCancel.StartTask() 方法。要取消一个或多个正在运行的线程，请调用 StartCancel.CancelTask() 方法。 <!--googl
使用 Visual Basic .NET 进行多线程编程
weixin_30607659的博客
04-29 1332
摘要：.NET 框架提供了新的类，可以方便地创建多线程应用程序。本文介绍如何使用 Visual Basic® .NET 的多线程编程技术来开发效率更高、响应速度更快的应用程序。 目录 简介 多线程处理的优点 创建新线程 同步线程 线程计时器 取消任务 总...
c++ 高并发服务器详解
aDiligentCigarette的博客
11-09 3657
本文列举两个c++并发服务器，并尝试分析其中语法，若有错误，还望指正。这里不讨论socket和c/s架构，只对服务器端做分析。 服务器处理任务的大体流程是: 服务器启动线程，开始等待和接收任务，处理任务，退出线程。接收任务时，任务被添加在全局的一个队列，被所有线程共享，这时就考虑一个同步。如果任务队列为空或者太满，还需要考虑线程池的容量大小。 这不禁让人想起了经典的生产者—消费着模式，生产者生产一个任务，消费者耗费一个任务，很类似，大概流程如下草图所示: 这里用到了互斥量锁，条件变量，..
C++11的thread代码分析
热门推荐
横云断岭的专栏
06-29 1万+
本文分析的是llvm libc++的实现：http://libcxx.llvm.org/ class thread thread类直接包装了一个pthread_t，在linux下实际是unsigned long int。 class thread { pthread_t __t_; id get_id() const _NOEXCEPT {return __t_;} }
python 线程的使用 python线程基础知识，提供python2示例代码，供参考学习
08-18
总结，理解Python中的线程概念以及如何在Python2和Python3中使用线程是非常基础且重要的技能。在编写多线程程序时，应关注线程安全、同步问题以及如何有效地利用线程来提升程序的并发能力。同时，了解GIL的存在及其...
多线程基础总结.xmind
12-02
多线程基础理论, 多线程中常用API,多线程的实现方式, 线程池以及创建线程池相关API, 常见的设计模式等内容
多线程基础部分.md，学习代码
最新发布
06-21
我们将围绕标题“多线程基础部分”展开，结合描述和标签，重点关注Java中的多线程、软件设计以及并发编程的相关概念。 首先，让我们理解什么是多线程。在计算机科学中，线程是程序执行的基本单位，一个进程可以包含...
MFC多线程编程.pdf
10-30
#### 二、多线程基础理论 ##### 2.1 问题提出 以一个简单的例子开始——一个名为`SingleThread`的应用程序，包含一个主对话框和一个按钮，当点击这个按钮时，程序会执行一个6秒的延时操作。在这6秒内，用户会发现...
c# Thread.Abort()和Thread.ResetAbort()的使用
皮皮君的博客
01-09 3847
c# Thread.ResetAbort()的使用 Thread类的Abort()方法用于终止正在运行的线程。它可以强行终止线程，而不管线程是否是sleep中。 执行了Abort()后，被终止的线程就会运行到try{}catch{}语句当中，因为是强行终止，catch后的语句则不再运行。除非在catch语句中执行Thread.ResetAbort()这个静态方法。 先举例没有ResetAbort(...
线程和std::shared_ptr智能指针使用
mindfusion的博客
01-09 1132
//定义线程指针 std::unique_ptr<std::thread> thread_; //指向定义函数 threadCapture_.reset(new std::thread([this]() { func(); } )); #功能函数 void func() { while(1) { std::chr...
Thread 的 _event.Set(),_event.Reset()；_event.WaitOne()； 用法示例
hewusheng10的专栏
11-17 1017
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Threading; namespac...
ThreadX(三)------线程thread
heartbeats的博客
08-16 2256
ThreadX——线程使用常用APIthreadx_demo 常用API tx_thread_create tx_thread_delete tx_thread_preemption_change tx_thread_priority_change tx_thread_relinquish tx_thread_reset tx_thread_resume tx_thread_sleep tx_thread_suspend tx_thread_terminate tx_thread_wait_abort
C++11中多线程例子
周翔的专栏
03-31 3568
C++11开始，自带线程相关的操作库。这里举个例子，以并发编程最经典的例子，生产者消费者的例子来示例在C++11使用标准库提高的线程库来进行并发编程。这里为了方便线程的使用，参考了android源码中对thread的封装。class Thread { public: Thread() : m_running(false) { } virtual ~Thr
C++基础
梅杏柿的博客
04-13 626
1、空类有多大，都有什么函数 构造，析构，拷贝构造，赋值运算符，取地址运算符，const取地址运算符 2、struct内存对齐 3、内存泄露的情况 4、指针和引用的区别 5、野指针产生与避免 6、27、四种智能指针及底层实现：auto_ptr、unique_ptr、shared_ptr、weak_ptr 28、shared_ptr中的循环引用怎么解决？（weak_ptr） 8、vector迭代器失效 ...
多线程编程（二） ----- std::thread
qq_40140790的博客
08-15 1337
c++11封装了有关多线程编程的类库，使用他们会使多线程编程更为轻松简单，这里就总结一下std::thread的简单实用。 使用std::thread之前我们先来了解有关的函数头和其相关的成员方法 相关的头文件有<thread> <future> <mutex> <condition_variable> <atomic> <co...
C#/.NET 对ManualResetEvent的重新封装MutipleThreadResetEvent
老陈聊架构
07-03 1017
看这篇文章之前，你必须对ManualResetEvent有一定的了解才行。 ManualResetEvent主要被用作线程同步，线程等待。它可以通知一个或多个正在等待的线程已发生事件，允许线程通过发信号互相通信，来控制线程是否可心访问资源 当一个线程开始一个活动（此活动必须完成后，其他线程才能开始）时，它调用 Reset 以将 ManualResetEvent 置于非终止状态。此线程可被视为控制 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值