线程创建 线程同步 线程状态

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量58 收藏
点赞数
文章标签： java jvm 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76537556/article/details/130139874
版权


第一章 多线程的概念
    1.1线程与进程
    进程:
        是指一个内存中运行的应用程序, 每个进程都有一个独立的内存空间, 一个应用程序可以同时运行多个程序;
        进程是程序的一次执行过程,是系统运行程序的进本单位;
    线程:
        是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程,也可以有多个线程;
    进程与线程的区别:
        进程:有独立的内存空间,进程中数据存放空间(堆内存与栈内存)是独立的,至少有一个线程.
        线程:堆空间是共享的, 栈空间是独立的,线程消耗的资源比进程小得多;
        
第二章 线程的创建--继承方式
    2.1继承Thread类方式
    java使用java.lang.Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例.
    java中通过继承Thread类来创建并启动多线程的步骤如下:
        1. 定义Thread类的子类, 并重写该类的run()方法;  该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体;
        2. 创建Thread子类的实例, 即创建了线程对象
        3. 调用线程对象的start()方法来启动该线程(即调用Thread类的start方法);
    代码实例:


        自定义线程类: 

 public class MyThread extends Thread{
            /*
            重写run方法, 完成该线程程序执行的逻辑
            */
            @Override
            public void run(){
                for(int i = 0; i< 200; i++){
                    System.out.println("自定义线程正在执行"+i);
                }
            }
        }
        测试类:
        public static void main(String[] args){
            //创建自定义线程对象
            MyThread mt = new MyThread();
            //开启新线程
            mt.start();
            //在主方法中执行for循环
            for(int i = 0; i< 200;i++){
                System.out.println("main线程"+i);
            }
        }


        
    2.2 run()方法和start()方法
        run()方法:
            是线程执行的任务方法，每个线程都会调用run()方法执行，我们将线程要执行的任务代码都写在run()方法中就可以被线程调用执行。
        start()方法:
            开启线程，线程调用run()方法;
        注意: 一个线程只能被启动一次!!
        
    2.3 线程名字的设置与获取
        String getName()可以获取到线程的名字。
        setName(String name)设置线程的名字。
        通过Thread类的构造方法Thread(String name)也可以设置线程的名字
        
        获取运行main方法线程的名字:
        static Thread CurrentThread() 获取当前线程对象
        代码实例:

 public class MyThread extends Thread{
            public void run(){
                System.out.println("线程名称:"+getName());
                System.out.println("线程名称:"+Thread.CurrentThread().getName());
                
            }
        }
         测试类:
         public class Demo{
            public static void main(String[] args){
                //创建自定义线程对象
                MyThread mc= new MyThread();
                //设置线程名字
                mc.setName("旺财");
                //开启新线程
                mc.start();
            }
        }


        注意：线程是有默认名字的，如果我们不设置线程的名字，JVM会赋予线程默认名字Thread-0,Thread-1;
        
    为什么要继承Thread类?
        Thread类就是线程类, 具有线程最基本的属性与功能; 比如  设置线程名  开启线程
        继承Thread类  就可以直接使用这些功能;
    那为什么不直接创建Thread类对象 开启线程?
        Thread t = new Thread();
        t.start();
        这样虽然开启了线程  但是运行的是Thread类的main方法, 这个run方法中执行的内容
        并不是我们想要的, 所以我们继承Thread类 重写run方法 这样运行的就是我们自己的run方法;
        
        
第三章 线程的创建--实现方式
    3.1 线程创建的第二种方式  实现Runnable接口
        1. 定义实现类, 实现 Runnable接口
        2. 重写run方法(线程任务)
        3. 开启线程
            创建实现类对象
            创建Thread对象 传入线程任务
                    public Thread(Runnable r)
            调用Thread的start方法  开启线程
    代码实例:
      

  public class MyRunnable implements Runnable{
            public void run (){
                for(int i = 0; i < 20; i++){
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
        }
        测试类:
        public class Demo{
            public static void main(String[] args){
                //创建(自定义类)实现类对象, 线程任务对象
                MyRunnable mr = new MyRunnable();
                //创建线程对象(将要执行的线程任务 传递给Thread对象)
                Thread t = new Thread(mr);
                t.start();
                for(int i = 0; i < 20; i++){
                    System.out.println(" main "+i);
                }
            }
        }


    为什么有了继承的方式 还要有实现接口的方式?
        1. 实现Runnable接口的方式 避免了单继承的局限性
                如果一个类已经有了父类  还想开线程 只能通过实现接口的方式
        2. 解耦合 线程任务与线程对象分离
        3. 更符合面向对象 更容易实现 多个线程共享一个任务
        
    3.2 匿名内部类方式创建线程
        使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法
        
        代码演示:

 public class NoNameInnerClassThread {
            public static void main(String[] args) {           
        //        new Runnable(){
        //            public void run(){
        //                for (int i = 0; i < 20; i++) {
        //                    System.out.println("张宇:"+i);
        //                }
        //            }  
        //           }; //---这个整体  相当于new MyRunnable()
                Runnable r = new Runnable(){
                    public void run(){
                        for (int i = 0; i < 20; i++) {
                            System.out.println("张宇:"+i);
                        }
                    }  
                };
                new Thread(r).start();
        
                for (int i = 0; i < 20; i++) {
                    System.out.println("费玉清:"+i);
                }
            }
        }


        
第四章 Thread类API    
    4.1 睡眠sleep方法
        public static void sleep(long time); 让当前线程进入到睡眠状态,到毫秒后自动醒来继续执行
    代码演示:
 

       public class Test{
            public static void main(String[] args){
                for(int i = 1;i<=5;i++){
                    Thread.sleep(1000);
                    System.out.println(i)   
                } 
            }
        }


    4.2 设置线程优先级(了解)
        线程的优先级被划分为10级,值分别为1-10,其中1最低,10最高.线程提高了3个常量来表示最低,最高,以及默认优先级:
            public static final int MIN_PRIORITY   //1 最低优先级
            public static final int NORM_PRIORITY  //5 默认优先级
            public static final int MAX_PRIORITY   //10 最大优先级
            
            public final void setPriority(int newPriority)更改线程的优先级。 
        
    4.3 用户线程与守护线程(了解)    
        用户线程与守护线程
            我们正常写的代码都是用户线程
        守护线程
            用户线程存在 守护线程可以执行 用户线程执行完  守护线程即使没执行完 jvm也直接退出
            GC就是一个守护线程
            
        public final void setDaemon(boolean on) on的值为true将线程设置为守护线程, 注意一定要在开启线程之前设置
        
    代码演示:

public class Test02 {
            public static void main(String[] args)  {
                Thread t1 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 100; i++) {
                            try {
                                Thread.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
        
                            System.out.println("t1   "+i);
                        }
                    }
                });
                //如果不设置t1为守护线程 由于t1睡眠时间比t2睡眠时间长
                //t1一定是后执行完 ,当t2全部执行结束后,t1再慢慢将剩下的执行完
                //但是如果将t1设置为守护线程 当t2执行完毕后,t1也不再执行了 直接退出jvm
                //t1.setDaemon(true);//设置t1为守护线程
                t1.start();
                Thread t2 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 100; i++) {
                            try {
                                Thread.sleep(50);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println("t2 "+i);
                        }
                    }
                });
                t2.start();
            }
        }


        
    4.4 join方法    
        join方法是让 当前线程等待,调用方法的线程进行插队先执行,执行完毕后,在让当前线程执行.
        对其他线程没有任何影响.注意 此处的当前线程不是调用方法的线程 而是Thread.currentThread().
        
    代码演示:

  public class Test {
            public static void main(String[] args) throws InterruptedException {
                Thread t1 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 10; i++) {
                            System.out.println("t1   "+i);
                        }
                    }
                });
                Thread t2 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 10; i++) {
                            System.out.println("t2   "+i);
                        }
                    }
                });
                t1.start();
                //注意 此时当前线程是main线程
                //main线程进入等待,让t1线程执行. 由于此时main等待 所以t2还没有执行
                //t1执行完毕后 main和t2抢夺cpu资源 执行
                // t1.join();
                t2.start();
                //如果t1.join放在这里 那么main进入到等待 t2已经开启了
                //t1 t2互相抢夺资源
                //main一定是在 t1执行完毕后 才会执行
                //那么就会有两种情况  t1执行完毕  t2没执行完 main和 t2进行抢夺
                //t1执行完毕  t2也执行完毕了  main自己执行
                //t1.join();
                for (int i = 0; i < 10; i++) {
                    System.out.println("main "+i);
                }            }
        }


        
    面试题:
    现在有T1,T2,T3 三条线程,同时开启,如何保证T2在T1执行完毕后执行,T3在T2执行完毕后执行?    
    
    代码实例:

  public class Test02 {
            public static void main(String[] args) throws InterruptedException {
                Thread t1 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 10; i++) {
                            System.out.println("t1   "+i);
                        }
                    }
                });
                Thread t2 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            //如果t2抢到,等待 让t1先执行
                            t1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        for (int i = 0; i < 10; i++) {
                            System.out.println("t2   "+i);
                        }
                    }
                });
                Thread t3 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            //如果t3抢到,等待 让t2先执行
                            t2.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        for (int i = 0; i < 10; i++) {
                            System.out.println("t3   "+i);
                        }
                    }
                });
                t1.start();
//                t1.join();
                t2.start();
//                t2.join();
                t3.start();
            }
        }

    4.5 线程停止(了解)
        public final void stop()  直接中断线程 此方法已过时 不安全
        public boolean isInterrupted() 获取线程是否中断的状态 如果中断返回true 没中断返回false
        public void interrupt()  中断线程 此时调用interrupted方法 会返回true  

 代码演示:

 public class Test02 {
            public static void main(String[] args)  {
                Thread t1 = new Thread(new Runnable() {
                    @Override
                    public void run() {

                        for (int i = 0; i <1000000 ; i++) {
                            System.out.println(i);
                            //是否有人要中断线程 如果有返回true 如果没有返回false
                            //让线程中断更为平滑 可以使用代码来控制中断
                            boolean b = Thread.currentThread().isInterrupted();
                            if(b){
                                break;
                            }
                        }
                    }
                });

                t1.start();

                try {
                    Thread.sleep(2000);

//                    t1.stop(); //方法已经过时 不安全
                    t1.interrupt();


                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

第五章 线程安全
    5.1 线程安全问题
    
        线程安全问题引发
            线程安全问题引发：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，
            一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全

    5.2 线程同步
        当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
        要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(**synchronized**)来解决。
        三种方法为:
            1.同步代码块
            2.同步方法
            3.锁机制
            
    5.2.1同步代码块
        同步代码块：线程操作的共享数据进行同步。synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
        格式:
            synchronized(同步锁){
                需要同步操作的代码
            }
        同步锁:
        同步锁又称为对象监视器。同步锁只是一个概念,可以想象为在对象上标记了一个锁.
        1. 锁对象 可以是任意类型。
        2. 多个线程对象  要使用同一把锁。
        注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

        代码演示:  

 public class Ticket implements Runnable{
            private int ticket = 100;
            private Object lock = new Object();
            /*
            * 执行卖票操作
            */
            @Override
            public void run() {
                //每个窗口卖票的操作 
                //窗口 永远开启 
                while(true){
                    synchronized (lock) {
                        if(ticket>0){//有票 可以卖
                            //出票操作
                            //使用sleep模拟一下出票时间 
                            try {
                                Thread.sleep(50);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                            //获取当前线程对象的名字 
                            String name = Thread.currentThread().getName();
                            System.out.println(name+"正在卖:"+ticket--);
                        }
                    }
                }
            }
        }

    5.2.2 同步方法
        同步方法:当一个方法中的所有代码，全部是线程操作的共享数据的时候，可以将整个方法进行同步。使用synchronized修饰的方法,就叫做同步方法,
        保证A线程执行该方法的时候,其他线程只能在方法外等着
    格式:
        public synchronized void method(){
            可能会产生线程安全问题的代码
        }
    使用同步方法代码如下：
      

 public class Ticket implements Runnable{
            private int ticket = 100;
            /*
            * 执行卖票操作
            */
            @Override
            public void run() {
                //每个窗口卖票的操作 
                //窗口 永远开启 
                while(true){
                    sellTicket();
                }
            }
    
            /*
            * 锁对象 是 谁调用这个方法 就是谁 
            *   隐含 锁对象 就是  this
            *    
            */
            public synchronized void sellTicket(){
                if(ticket>0){//有票 可以卖    
                    //出票操作
                    //使用sleep模拟一下出票时间 
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //获取当前线程对象的名字 
                    String name = Thread.currentThread().getName();
                    System.out.println(name+"正在卖:"+ticket--);
                }
            }
        }

    5.2.3 lock锁
        java.util.concurrent.locks.Lock机制提供了比*synchronized*代码块和*synchronized*方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

        Lock锁也称同步锁，加锁与释放锁方法化了，如下：
            public void lock() `:加锁。
            public void unlock()`:释放锁

        代码演示:
      

 public class Ticket implements Runnable{
            private int ticket = 100;
    
            Lock lock = new ReentrantLock();
            /*
            * 执行卖票操作
            */
            @Override
            public void run() {
                //每个窗口卖票的操作 
                //窗口 永远开启 
                while(true){
                    lock.lock();
                    if(ticket>0){//有票 可以卖
                        //出票操作 
                        //使用sleep模拟一下出票时间 
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        //获取当前线程对象的名字 
                        String name = Thread.currentThread().getName();
                        System.out.println(name+"正在卖:"+ticket--);
                    }
                    lock.unlock();
                }
            }
        }


第六章 线程状态
    6.1 线程状态概述
        当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。
        在API中java.lang.Thread.State这个枚举中给出了六种线程状态：
        
        | 线程状态                | 导致状态发生条件                                             |
        | ----------------------- | ------------------------------------------------------------ |
        | NEW(新建)               | 线程刚被创建，但是并未启动。还没调用start方法。              |
        | Runnable(可运行)        | 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。 |
        | Blocked(锁阻塞)         | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
        | Waiting(无限等待)       | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
        | Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
        | Teminated(被终止)       | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |

    6.2 等待与唤醒
        Object类的方法
        public void wait() : 让当前线程进入到等待状态 此方法必须锁对象调用.
        
        代码演示:
      

 public class Demo1_wait {
            public static void main(String[] args) throws InterruptedException {
            // 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行.
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("begin wait ....");
                        synchronized ("") {
                            "".wait();
                        }
                        System.out.println("over");
                    } catch (Exception e) {
                    }
                }
            }).start();
        }


        
        public void notify() : 唤醒当前锁对象上等待状态的线程  此方法必须锁对象调用.
        代码演示:

 public class Demo2_notify {
            public static void main(String[] args) throws InterruptedException {
                // 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行.
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println("begin wait ....");
                            synchronized ("") {
                                "".wait();
                            }
                            System.out.println("over");
                        } catch (Exception e) {
                        }
                    }
                }).start();
                //步骤2:  加入如下代码后, 3秒后,会执行notify方法, 唤醒wait中线程.
                Thread.sleep(3000);
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            synchronized ("") {
                                System.out.println("唤醒");
                                "".notify();
                            }
                        } catch (Exception e) {
                        }
                    }
                }).start();
            }
        }


       
  

effort_76537556
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
QT线程同步与异步处理
断点
12-04 5319
QT多线程专栏共有14篇文章，从初识线程到、QMutex锁、QSemaphore信号量、Emit、Sgnals、Slot主线程子线程互相传值同步变量、QWaitCondition、事件循环、QObjects、线程安全、线程同步、线程异步、QThreadPool线程池等线程操作进行了全面！深入！的研究和详细的说明
python 获取子线程状态_python线程状态
weixin_33365214的博客
01-13 3256
python怎么判断线程的状态python中如何在父线程中检测其子线程是否处于运行状态子线程有一个方法 is_alive() 运行时会返回Bool值Truepython 在线程函数中如何实现线程的暂停、恢复和终我们都知道python中可以是threading模块实现多线程, 但是模块并没有提供暂停, 恢复和停止线程的方法, 一旦线程对象调用start方法后, 只能等到对应的方法函数运行完毕. 也就...
C#的线程同步
IT技术猿猴的博客
04-05 4045
使用线程有几个原因。假设从应用程序中进行网络调用需要一定的时间。我们不希望用户界面停止响应，让用户一直等待直到从服务器返回一个响应。用户可以同时执行其他一些操作，或者甚至取消发送给服务器的请求。这些都可以使用线程来实现。 线程是程序中独立的指令流。使用C编写任何程序时，都有一个入口点:Main()方法。程序从Main(方法的第一条语句开始执行，直到这个方法返回为止。 这种程序结构非常适合于其中有一个可识别的任务序列的程序，但程序常常需要同时完成多个任务。线程对客户端和服务器端应用程序都非常重要。
Android面试之线程同步的方法
qq_39431405的博客
12-06 3859
一 什么是进程和线程？进程和线程的区别？ 进程是资源分配的最小单元,线程是程序执行的最小单元(进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位) 进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。 而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很
Linux线程的创建与同步
XXXTENTAC1ON的博客
12-01 3694
线程的概念、实现；线程使用；线程安全；线程同步等只是概念
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
线程的几种状态转换
过往很淡的博客
08-12 3629
线程在一定条件下，状态会发生变化。线程一共有以下几种状态： 1、新建状态(New)：新创建了一个线程对象。 2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。 3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。 4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行
Java synchronized关键字实现线程同步
WYSCODER的博客
04-02 6078
synchronized关键字实现线程同步
Python多线程—线程同步
Lesour的博客
03-25 8857
当多个线程同时读写同一份共享资源的时候，可能会引起冲突。 这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。 线程同步的真实意思和字面意思恰好相反。 线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。 Python threading模块提供了Lock/RLock、Condition、queue、Ev...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
day17_线程创建、线程同步、线程状态.pdf
11-02
day17_线程创建、线程同步、线程状态.pdf
操作系统——实验四 windows中线程的创建和同步控制
08-05
在windows的环境下，创建一个控制台进程，此进程创建两个并发线程，一个是读线程，另一个是写线程。这两个线程共享一个数组A,写线程对数组分别进行10次写操作，每次写操作对A的每个元素赋一个相同的值；读线程对数组...
浅析c# 线程同步
12-17
所以可以通过线程同步来处理它。 主要场景如：存款，取款等交易业务处理。 线程同步的优点 一致性维护 无线程干扰 C#锁定 使用 C# lock关键字同步执行程序。它用于为当前线程锁定，执行任务，然后释放锁定。它确保...
详解c# 线程同步
12-17
前面的文章都是讲创建多线程来实现让我们能够更好的响应应用程序，然而当我们创建了多个线程时，就存在多个线程同时访问一个共享的资源的情况，在这种情况下，就需要我们用到线程同步，线程同步可以防止数据（共享...
C#线程同步的几种方法总结
12-20
这些情况你都可以创建一个子线程去处理，然而，多线程不可避免地会带来一个问题，就是线程同步的问题。如果这个问题处理不好，我们就会得到一些非预期的结果。 在网上也看过一些关于线程同步的文章，其实线程同步有...
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1008
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 805
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 296
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
C# 线程并发，线程同步
07-27
在 C# 中，线程并发和线程同步是处理多线程编程中重要的概念。 线程并发指的是多个线程同时执行，这可能导致资源竞争和不确定的结果。为了避免这种情况，我们可以使用线程同步机制来确保线程之间的协调和有序执行。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值