来学习线程啦

最新推荐文章于 2024-06-09 18:49:49 发布
最新推荐文章于 2024-06-09 18:49:49 发布
阅读量818 收藏 16
点赞数 14
文章标签： 学习 java windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Islucas/article/details/138806047
版权

线程的相关概念

程序

简单点说：程序就是我们写的代码；也可以理解为：为完成特定任务，用某种语言编写的一组指令的集合

进程

  • 进程是指运行中的程序。
    比如：我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间
    当我们使用迅雷，又启动一个进程，操作系统将为迅雷分配新的内存空间
  • 进程是程序得一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程

什么是线程

  • 1，线程由进程创建的，是进程的一个实体。
    比如：在迅雷中正在下载的一个文件 就是一个进程
  • 2，一个进程可以拥有多个线程

其他相关概念

  • 1，单线程：在同一时刻，只允许执行一个线程
  • 2，多线程：在同一时刻，可以执行多个线程。
    比如：一个QQ进程，可以同时打开多个聊天框
  • 3，并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发
    在这里插入图片描述
  • 4，并行：同一时刻，多个任务同时执行。多核cpu可以实现并行。
    在这里插入图片描述

线程基本使用

创建线程的两种方式

继承Thread类，重写run方法

在这里插入图片描述

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();//启动线程-> main 线程启动一个子线程 Thread-0    最终会执行 cat 的 run 方法
        //为什么调用start方法
        // (1)
        //  public synchronized void start() {
        //   start0();
        //   }
        // (2)
        //start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现
        //真正实现多线程的效果， 是 start0(), 而不是 run
        //        private native void start0();

        // 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行..
        System.out.println("主线程的线程名" + Thread.currentThread().getName());
        for(int i = 0; i < 60; i++) {
            System.out.println("主线程 i=" + i);
        //让主线程休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        //该线程每隔1秒，在控制台输出"喵喵，我是小猫咪"
        while (true) {
            System.out.println("喵喵，我是小猫咪" + "线程名=" + (++times) + Thread.currentThread().getName());
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80) {
                break;//当times到80，退出while，这是线程也就退出
            }
        }
    }
}

调用start()方法示意图
在这里插入图片描述
注意：主线程和子线程会交替执行（并发/并行）

实现Runnable接口，重写run方法

说明：
1，java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来创建线程显然不可能了
2，java设计者们提供了另一个方式创建线程，就是通过实现Runnable接口来创建线程

在这里插入图片描述

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
//        dog.start();
        // public Thread(Runnable target) {
        //        this(null, target, "Thread-" + nextThreadNum(),
        //代理模式： Thread类有个如上构造器，需要传入Runnable类型的参数
        //                               Dog正好实现了Runnable类型
        //                               Dog类型可以代理Runnable类型传入
        Thread thread = new Thread(dog);
        thread.start();

    }
}
class Dog implements Runnable{
    int times = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hi" + (++times) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times==10) {
            break;}
        }

        }
    }

线程使用应用案例-多线程执行

在这里插入图片描述

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread1.start();//启动第 1 个线程
        thread.start();//启动第 2 个线程
    }
}
class T1 implements Runnable{
    int count = 0 ;
    @Override
    public void run() {
        while (true){
            System.out.println("hello,world"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count==10){
                break;
            }
        }
    }
}
class T2 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hi" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

线程如何理解

  • 通过主线程创建不同的线程去做不同的事；

在这里插入图片描述

  • 所有线程运行完之后进程才退出
    在这里插入图片描述

创建线程两种方式的区别（继承Thread 和 实现Runnable 的区别）

  • 1，通过java的设计来看，通过继承Thread 或者实现Runnable 接口来创建线程本质上没有区别。本质上Thread类本身即实现了Runnable接口
  • 2，实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的机制，建议使用Runnable
    在这里插入图片描述

出现超卖现象

public class Sell {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        //这里会出现超卖现象
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();

    }
}

class SellTicket implements Runnable {
    public int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(12);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数"+(--ticketNum));
        }
    }
}

线程终止

基本说明

  • 1，当线程完成任务后，会自动退出
  • 2，还可以通过使用变量来控制run方法退出的方式停止线程
public class ThreadExit {
    public static void main(String[] args) {
        AThread aThread = new AThread();
        Thread thread = new Thread(aThread);
        thread.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //4，更改AThread类中的loop变量，停止线程
        aThread.setLoop(false);
    }
}
class AThread implements Runnable{
    //1，定义标记变量，默认为true
    private boolean loop =true;
    //2，将loop作为循环条件
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread运行中");
        }
    }
    //3，提高公共的set方法，用于更细loop
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常用方法

常用方法第一组

  • 1，setName：设置线程名称，使之与参数name相同
  • 2，getName：返回该线程的名称
  • 3，start：使该线程开始执行；java虚拟机底层调用该线程的start0 方法
  • 4，run：调用线程对象 run 方法
  • 5，setPriority：更改线程的优先级
  • 6，getPriority：获取线程的优先级
  • 7，sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
  • 8，interrupt：中断线程

注意事项

  • 1，start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会再启动新线程

  • 2，线程优先级的范围
    在这里插入图片描述

  • 3，interrupt：中断线程。但并没有真正的结束线程，所以一般用于中断正在休眠的线程

  • 4，sleep：线程的静态方法，使当前线程休眠

方法的案例演示

public class ThreadMethod {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.setName("小笼包");
        //设置优先级
        threadDemo.setPriority(Thread.MIN_PRIORITY);
        threadDemo.start();

        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hi"+i);
        }
        //测试优先级
        System.out.println(threadDemo.getName()+"线程的优先级"+threadDemo.getPriority());

        threadDemo.interrupt();//当执行到这里，就会中断线程的休眠
    }
}
class ThreadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"吃包子~~~"+i);
        }
        try {
            System.out.println("休眠中~~~~~");
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            //当该线程执行到Interrupt方法时，会catch一个异常，可以加入自己的业务代码
            //InterruptedException 是捕获到一个中断异常
            System.out.println(Thread.currentThread().getName()+"被interrupt了");

        }
    }
}

常用方法第二组

在这里插入图片描述

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程（小弟）"+i);
            Thread.sleep(500);
            System.out.println("主线程(小弟)让 子线程(老大)先吃");
//            线程插队：先执行完插入的所有任务(t 子线程中)，再执行主线程任务
            t.join();
            //礼让 不一定成功
//            Thread.yield();
        }

    }
}
class T extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Hello~~~"+i);
        }
    }
}

用户线程和守护线程

  • 1，用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
  • 2，守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  • 3，常见的守护线程：垃圾回收机制

守护线程的案例

public class ThreadMethod03 {
    public static void main(String[] args) {
        MyDaemon myDaemon = new MyDaemon();
        //为MyDaemon类 添加守护线程：当所有的用户线程结束，守护线程自动结束
        myDaemon.setDaemon(true);
        myDaemon.start();

        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("主线程"
            );
        }



    }
}
class MyDaemon extends Thread{
    @Override
    public void run() {
        for(;;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("守护线程");
        }
    }
}

线程的声明周期

JDK 中用 Thread.State 枚举表示了线程的几种状态

  • 五种状态
    在这里插入图片描述
  • 线程状态转换图（将RUNNABLE一种状态 分为 Ready 和 Running 两种状态 ）
    在这里插入图片描述
    状态的示例代码
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        TT tt = new TT();
        System.out.println(tt.getName()+"状态"+tt.getState());//状态：NEW  RUNNABLE
        tt.start();

        while (Thread.State.TERMINATED!=tt.getState()){
            System.out.println(tt.getName()+"状态"+tt.getState());//状态：TIMED_WAITING
            Thread.sleep(500);
        }
        System.out.println(tt.getName()+"状态"+tt.getState());//状态：TERMINATED
    }
}
class TT extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

            break;
        }
    }
}

线程的同步Synchronized

线程的同步机制

  • 1，在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整型
  • 2，也可以理解为：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作（上厕所）

同步具体方法

  • 1，同步代码块
    Synchronized(对象){//得到对象的锁，才能操作同步代码
    //需要被同步代码
    }
  • 2，Synchronized还可以放在方法声明中，表示整个方法-为同步方法
    public Synchronized void m（String name）{
    //需要被同步的代码}
  • 3，如何理解：
    就好像某小伙伴上厕所前先把门关上(上锁)，那么其他小伙伴就可以使用厕所了
public class Sell {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        //这里会出现超卖现象
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();

    }
}

class SellTicket implements Runnable {
    public int ticketNum = 100;
    public synchronized void m(){//同步方法，在同一时刻，只能有一个线程来执行sell方法
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(12);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出一张票"+"剩余票数"+(--ticketNum));
        }
    }

    @Override
    public  void run() {
       m();
    }
}

互斥锁

基本介绍

  • 1，Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
  • 2，每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
  • 3，关键字Synchronized来与对象的互斥锁联系，当某个对象用Synchronized修饰时，表面该对象在任一时刻只能由一个线程访问
  • 4，同步的局限性：导致程序的执行效率要降低
  • 5，同步方法(（非静态的）的锁可以是this，也可以是其他对象（要求是同一对象）
  • 6，同步方法(（静态的）的锁为当前类本身

注意细节

  • 1，同步方法如果没有使用static修饰：默认锁对象为this
  • 2，如果方法使用static修饰，默认锁对象：当前类.class
  • 3，实现的落地步骤：
    先分析上锁的代码
    选择同步代码块或同步方法
    要求多个线程的锁对象为同一个即可
public class Sell {
    public static void main(String[] args) {
//        SellTicket sellTicket = new SellTicket();
//        //这里会出现超卖现象
//        new Thread(sellTicket).start();
//        new Thread(sellTicket).start();
//        new Thread(sellTicket).start();
        SellTicket sellTicket2 = new SellTicket();
        Thread thread1 = new Thread(sellTicket2);
        thread1.start();
        Thread thread2 = new Thread(sellTicket2);
        thread2.start();
        Thread thread3 = new Thread(sellTicket2);
        thread3.start();

    }
}

class SellTicket implements Runnable {
    public int ticketNum = 100;
    private boolean loop = true;
    Object object = new Object();
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket.class) {
            System.out.println("m2");
        }*/

    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this 对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在 this 对象
    public /*synchronized*/ void m(){//同步方法，在同一时刻，只能有一个线程来执行sell方法
        synchronized (/*this*/object) {
            while (loop) {
                if (ticketNum <= 0) {
                    System.out.println("售票结束");
                    break;
                }
                try {
                    Thread.sleep(12);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum));
            }
        }
    }

    @Override
    public  void run() {
       m();
    }
}

线程的死锁

基本介绍

多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程中一定要避免死锁发生

释放锁

下面操作会释放锁

  • 1，当前线程的同步方法、同步代码块执行结束
    案例：上厕所
  • 2，当前线程在同步代码块、同步方法中遇到break、return
    案例：没有正常的完事，经历叫他修改bug，不得已出来
  • 3，当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
    案例：没有正常的完事，发现忘带纸，不得已出来
  • 4，当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
    案例：没有正常的完事，觉得需要酝酿，所以出来等会再进去

下面操作不会释放锁

  • 1，线程执行同步块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法，暂停当前线程执行，不会释放锁
    案例：上厕所，太困了，在坑位上眯一会
  • 2，线程执行同步代码块时，其他线程调用了该线程的suspend()方法，将该线程挂起，该线程不会释放锁
    提示：应尽量避免使用suspend()和resume()来
Islucas
关注
  • 14
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程生命周期
weixin_43178406的博客
09-14 3万+
本文主要介绍了线程生命周期，希望能对学习线程的同学们有所帮助。 文章目录 1. 综述 2. 线程的生命周期
labview多线程学习
09-03
labview多线程学习
关于多线程学习总结
03-02
经常看到一些招聘上要求应聘者必须熟练掌握多线程，而对于我这个着实的菜鸟来说多线程这个概念虽然经常听到，但是在实际操作中用的比较少，而且了解的也比较浅显，所以乘着这休息的几天天好好的学习学习，补上这方面的知识。PS：本文只是多线程这方面学习的记录，并不是对多线程的深入探讨，如果你和我一样对多线程不甚了解，可以和我一起共同学习噢。也欢迎各位大神批评指正，小弟不胜感激！对于概念这个东东，我历来都不喜欢记，也老是记不住，我更愿意结合概念和实际操作来让它给我留下印象。但是学习前我们还是来看看几个概念，让它首先在我们脑海留下点影子再说。更过的线程意味着更多的内存消耗；线程的退出可能会对程序带来麻烦；处理不
Java基础巩固之线程学习
01-20
一、线程的学习 　　线程是程序中执行单个任务的顺序的流程。 　　线程创建的两种方式： 　　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { @Override publicvoidrun() { while(true) { System.out.println(Thread.currentThread().getName()); } } }; thread.start(); } 　　2、实现Runnable接口的
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
C#学习笔记之线程安全
无所谓的专栏
11-30 3569
待续
Go学习笔记—多线程
koooooooo5的博客
12-01 7096
多线程编程 ​ 一个进程可以包含多个线程，这些线程运行的一定是同一个程序（进程==程序），且都由当前进程中已经存在的线程通过系统调用的方式创建出来。进程是资源分配的基本单位，线程是调度运行的基本单位，线程不可独立于进程存在。 ​ 所有线程都有自己的线程栈，以此存放自己的私有数据（包含在进程的虚拟内存地址中）。一个进程中的很多资源也会被线程所共享，包括在当前进程虚拟内存地址中存放的代码段、数据段、堆、信号处理函数、文件描述符（非负整数）。正因如此，创建一个线程时不会像创建一个进程时那
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
深度学习多线程部署—学习笔记
studyeboy的专栏
09-20 4338
文章目录Flaskgunicorn 部署Flask项目gunicorn架构并发 vs. 并行安装gunicorn启动gunicorngunicorn配置文件列出所有进程 Flask Flask默认是单进程、单线程阻塞的任务模式，在项目上线的时候可以通过nginx+gunicorn的方式部署flask任务，但是在开发的过程中如果想通过延迟的方式测试高并发，需要在app.run()中通过threade...
Python 多线程学习
Herishwater的博客
05-10 3474
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
真的还有必要学习JAVA多线程吗？
02-19 5万+
JAVA多线程是不是真的没必要再学了？
线程安全问题的学习
weixin_47651920的博客
03-08 5004
一.有关线程安全问题 1.什么是线程安全 多线程并发执行某个代码时，没有产生逻辑上的错误，就是线程安全的。 2.线程不安全的例子 代码： package thread.example; public class CountThread { public static int count = 0; public static void main(String[] args) throws InterruptedException { Thread threa
YDT .netcore学习笔记
focus-unchanged-thing
06-07 175
net core和java运行性能对比。这个例子c#比java快了将近1倍。同时占用更少的内存，支持跨平台。所以做游戏用c#可能是更合适的。1..NET Core理论基础。
Elixir学习笔记——二进制、字符串和字符列表
chenxupest的专栏
06-04 750
在“基本类型”中，我们学习了一些关于字符串的知识，并使用 is_binary/1 函数进行检查："hello"true在本章中，我们将明确二进制到底是什么、它们与字符串的关系以及 Elixir 中单引号值“like this”的含义。虽然字符串是计算机语言中最常见的数据类型之一，但它们却非常复杂，经常被误解。要理解 Elixir 中的字符串，我们必须了解 Unicode 和字符编码，特别是 UTF-8 编码。
(delphi11最新学习资料) Object Pascal 学习笔记---第14章泛型第2节（标准类的泛型方法）
langfengyl的专栏
06-07 262
​ 使用泛型类型定义类可能是最常见的情况，但泛型类型也可以用于非泛型类。换句话说，一个普通的类也可以有一个泛型方法。在这种情况下，不仅要在创建类的实例时为泛型占位符指定类型，还要在调用方法时指定类型。：当我第一次编写这段代码时，可能是因为我想起了我的C++时代，我将参数写成了（t：T）。​ 所有上述调用都是正确的，因为这些调用中的参数类型可以是隐式的。如果使用类型和参数调用该方法，则参数的类型必须与泛型类型声明匹配。​ 如果在尖括号之间不指示类型调用该方法，则实际类型将从参数的类型中。
如何学习Golang语言!
最新发布
FengyangCoder的博客
06-09 352
起源与设计哲学：Go语言由Robert Griesemer、Rob Pike和Ken Thompson三位Google工程师设计，旨在解决现代编程中的一些常见问题，如编译速度、运行效率和并发编程。主要特点：Go语言的语法简单、编译速度快、运行效率高，支持静态类型和内存安全，具有垃圾回收功能，并且原生支持并发编程。
Transformer学习(4)
yin1331102028yin的博客
06-05 1001
Transformer学习(4)
【Docker学习】docker push简述
weixin_42206314的博客
06-04 551
docker push是docker pull的反向操作。我们将镜像上传到公共或私有镜像仓库就需要用到这个命令。
c# 多线程学习路线
02-24
学习C#多线程的路线可以按照以下步骤进行： 1. 先了解基本概念：开始学习之前，建议先了解多线程的基本概念和原理，包括线程、进程、并发、同步等相关概念。 2. 学习线程的创建和启动：学习如何在C#中创建和启动线程，可以使用Thread类或者Task类来实现。 3. 线程同步和互斥：学习如何在多线程环境下实现线程同步和互斥，以避免出现竞态条件和数据不一致的问题。可以学习使用锁、互斥量、信号量等机制来实现线程同步。 4. 学习线程间通信：学习如何在多线程环境下实现线程间的通信，以便线程之间能够进行数据交换和协作。可以学习使用共享内存、消息队列、事件等机制来实现线程间通信。 5. 学习线程池：学习如何使用线程池来管理和调度线程，以提高多线程应用程序的性能和效率。 6. 学习并发集合：学习如何使用并发集合来处理多线程环境下的数据共享和访问问题，包括并发队列、并发字典、并发栈等。 7. 学习异步编程：学习如何使用异步编程模型（Async/Await）来实现高效的异步操作，以提高多线程应用程序的响应性和吞吐量。 8. 学习线程安全性：学习如何编写线程安全的代码，以避免出现竞态条件和数据不一致的问题。可以学习使用锁、原子操作、线程本地存储等技术来确保线程安全性。 9. 实践项目：通过实践项目来巩固所学的多线程知识，可以选择一些具有多线程需求的项目来进行实践，例如网络服务器、并发任务处理等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值