不会多线程？把这20个源码自己执行一遍，你就会明白了

最新推荐文章于 2022-07-25 15:33:30 发布
最新推荐文章于 2022-07-25 15:33:30 发布
阅读量129 收藏
点赞数 2
分类专栏： 架构 面试 Java 文章标签： 多线程 java 编程语言 设计模式 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47908466/article/details/108710432
版权
Java 同时被 3 个专栏收录
167 篇文章 2 订阅
订阅专栏
架构
165 篇文章 0 订阅
订阅专栏
面试
145 篇文章 1 订阅
订阅专栏

提示：认真看完，花费不了多少时间，但是对你帮助应该很大，内容是阿里P7手打测试项目，这也是我让我朋友教自己家亲戚的时候，他留下的，一手资料，和大家分享

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说，代码大致框架是：

/**
 * @author Rollen-Holt 继承Thread类,直接调用run方法
 * */
class hello extends Thread {
     public hello() {
     }     public hello(String name) {
        this.name = name;
    }     public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行     " + i);
        }    }     public static void main(String[] args) {
        hello h1=new hello("A");
        hello h2=new hello("B");
        h1.run();        h2.run();    }     private String name;
}

先看一个简单的例子：

/**
 * @author Rollen-Holt 继承Thread类,直接调用run方法
 * */
class hello extends Thread {
     public hello() {
     }     public hello(String name) {
        this.name = name;
    }     public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行     " + i);
        }    }     public static void main(String[] args) {
        hello h1=new hello("A");
        hello h2=new hello("B");
        h1.run();        h2.run();    }     private String name;
}

【运行结果】：

A运行 0

A运行 1

A运行 2

A运行 3

A运行 4

B运行 0

B运行 1

B运行 2

B运行 3

B运行 4

我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。

当我们把上面的主函数修改为如下所示的时候：

 

public static void main(String[] args) {
        hello h1=new hello("A");
        hello h2=new hello("B");
        h1.start();        h2.start();    }

然后运行程序，输出的可能的结果如下：

A运行 0

B运行 0

B运行 1

B运行 2

B运行 3

B运行 4

A运行 1

A运行 2

A运行 3

A运行 4

因为需要用到CPU的资源，所有每次的运行结果基本是都不一样的，呵呵。

注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

那么：为什么我们不能直接调用run（）方法呢？

我的理解是：线程的运行需要本地操作系统的支持。

如果你查看start的源代码的时候，会发现：

 

public synchronized void start() {
        /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0 || this != me)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();        if (stopBeforeStart) {
        stop0(throwableFromStop);    }}private native void start0();

注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

通过实现Runnable接口：

 

大致框架是：

class 类名 implements Runnable{
方法1;
方法2；
…public void run(){
// other code…
}
属性1；
属性2；
…
 
}

 

来先看一个小例子吧：

/**
 * @author Rollen-Holt 实现Runnable接口
 * */
class hello implements Runnable {
     public hello() {
     }     public hello(String name) {
        this.name = name;
    }     public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行     " + i);
        }    }     public static void main(String[] args) {
        hello h1=new hello("线程A");
        Thread demo= new Thread(h1);
        hello h2=new hello("线程Ｂ");
        Thread demo1=new Thread(h2);
        demo.start();        demo1.start();    }     private String name;
}

【可能的运行结果】：

线程A运行 0

线程Ｂ运行 0

线程Ｂ运行 1

线程Ｂ运行 2

线程Ｂ运行 3

线程Ｂ运行 4

线程A运行 1

线程A运行 2

线程A运行 3

线程A运行 4

 

关于选择继承Thread还是实现Runnable接口？

其实Thread也是实现Runnable接口的：

class Thread implements Runnable {
    //…
public void run() {
        if (target != null) {
             target.run();
        }
        }
}

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html

Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

 

/**
 * @author Rollen-Holt 继承Thread类，不能资源共享
 * */
class hello extends Thread {
    public void run() {
        for (int i = 0; i < 7; i++) {
            if (count > 0) {
                System.out.println("count= " + count--);
            }        }    }     public static void main(String[] args) {
        hello h1 = new hello();
        hello h2 = new hello();
        hello h3 = new hello();
        h1.start();        h2.start();        h3.start();    }     private int count = 5;
}

 

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。

我们换为Runnable接口

 

class MyThread implements Runnable{
     private int ticket = 5;  //5张票
     public void run() {        for (int i=0; i<=20; i++) {
            if (this.ticket > 0) {
                System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--);
            }        }    }}public class lzwCode {         public static void main(String [] args) {        MyThread my = new MyThread();
        new Thread(my, "1号窗口").start();
        new Thread(my, "2号窗口").start();
        new Thread(my, "3号窗口").start();
    }}

　　

不会多线程？把这20个源码自己执行一遍，你就会明白了

 

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

 

总结一下吧：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

 

所以，本人建议大家尽量实现接口。

/**
 * @author Rollen-Holt
 * 取得线程的名称
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());        }    }     public static void main(String[] args) {
        hello he = new hello();
        new Thread(he,"A").start();
        new Thread(he,"B").start();
        new Thread(he).start();
    }}

【运行结果】：

A

A

A

B

B

B

Thread-0

Thread-0

Thread-0

说明如果我们没有指定名字的话，系统自动提供名字。

提醒一下大家：main方法其实也是一个线程。在java中所有的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

 

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

判断线程是否启动

/**
 * @author Rollen-Holt 判断线程是否启动
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }    }     public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he);
        System.out.println("线程启动之前---》" + demo.isAlive());
        demo.start();        System.out.println("线程启动之后---》" + demo.isAlive());
    }}

【运行结果】

线程启动之前---》false

线程启动之后---》true

Thread-0

Thread-0

Thread-0

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

 

线程的强制执行：

/**
     * @author Rollen-Holt 线程的强制执行
     * */
    class hello implements Runnable {
        public void run() {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName());
            }        }             public static void main(String[] args) {
            hello he = new hello();
            Thread demo = new Thread(he,"线程");
            demo.start();            for(int i=0;i<50;++i){
                if(i>10){
                    try{
                        demo.join();  //强制执行demo
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("main 线程执行-->"+i);
            }
        }
    }

【运行的结果】：

main 线程执行-->0

main 线程执行-->1

main 线程执行-->2

main 线程执行-->3

main 线程执行-->4

main 线程执行-->5

main 线程执行-->6

main 线程执行-->7

main 线程执行-->8

main 线程执行-->9

main 线程执行-->10

线程

线程

线程

main 线程执行-->11

main 线程执行-->12

main 线程执行-->13

．．．

 

线程的休眠：

/**
 * @author Rollen-Holt 线程的休眠
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + i);        }    }     public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();    }}

【运行结果】：（结果每隔2s输出一个）

线程0

线程1

线程2

 

线程的中断：

/**
 * @author Rollen-Holt 线程的中断
 * */
class hello implements Runnable {
    public void run() {
        System.out.println("执行run方法");
        try {
            Thread.sleep(10000);
            System.out.println("线程完成休眠");
        } catch (Exception e) {
            System.out.println("休眠被打断");
            return;  //返回到程序的调用处
        }
        System.out.println("线程正常终止");
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();
        try{
            Thread.sleep(2000);
        }catch (Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); //2s后中断线程
    }
}

【运行结果】：

执行run方法

休眠被打断

 

在java程序中，只要前台有一个线程在运行，整个java程序进程不会消失，所以此时可以设置一个后台线程，这样即使java进程消失了，此后台线程依然能够继续运行。

/**
 * @author Rollen-Holt 后台线程
 * */
class hello implements Runnable {
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "在运行");
        }    }     public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.setDaemon(true);
        demo.start();    }}

虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。

线程的优先级：

 

/**
 * @author Rollen-Holt 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }    }     public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        Thread h3=new Thread(new hello(),"C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();        h2.start();        h3.start();             }}

 

【运行结果】：

A运行0

A运行1

A运行2

A运行3

A运行4

B运行0

C运行0

C运行1

C运行2

C运行3

C运行4

B运行1

B运行2

B运行3

B运行4

。但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、

 

另外，主线程的优先级是5.

线程的礼让。

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。

 

/**
 * @author Rollen-Holt 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
            if(i==3){
                System.out.println("线程的礼让");
                Thread.currentThread().yield();
            }        }    }     public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        h1.start();        h2.start();             }}

A运行0

A运行1

A运行2

A运行3

线程的礼让

A运行4

B运行0

B运行1

B运行2

B运行3

线程的礼让

B运行4

 

 

同步和死锁：

【问题引出】:比如说对于买票系统，有下面的代码：

 

/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<10;++i){
            if(count>0){
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();                }                System.out.println(count--);            }        }    }     public static void main(String[] args) {
        hello he=new hello();
        Thread h1=new Thread(he);
        Thread h2=new Thread(he);
        Thread h3=new Thread(he);
        h1.start();        h2.start();        h3.start();    }    private int count=5;
}

【运行结果】：

5

4

3

2

1

0

-1

这里出现了-1，显然这个是错的。，应该票数不能为负值。

如果想解决这种问题，就需要使用同步。所谓同步就是在同一时间段中只有有一个线程运行，

其他的线程必须等到这个线程结束之后才能继续执行。

【使用线程同步解决问题】

采用同步的话，可以使用同步代码块和同步方法两种来完成。

 

【同步代码块】：

语法格式：

synchronized（同步对象）{

//需要同步的代码

}

但是一般都把当前对象this作为同步对象。

比如对于上面的买票的问题，如下：

 

/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<10;++i){
            synchronized (this) {
                if(count>0){
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();                    }                    System.out.println(count--);                }            }        }    }     public static void main(String[] args) {
        hello he=new hello();
        Thread h1=new Thread(he);
        Thread h2=new Thread(he);
        Thread h3=new Thread(he);
        h1.start();        h2.start();        h3.start();    }    private int count=5;
}

【运行结果】：（每一秒输出一个结果）

5

4

3

2

1

【同步方法】

也可以采用同步方法。

语法格式为synchronized 方法返回类型方法名（参数列表）{

// 其他代码

}

现在，我们采用同步方法解决上面的问题。

 

/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 10; ++i) {
            sale();        }    }     public synchronized void sale() {
        if (count > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();            }            System.out.println(count--);        }    }     public static void main(String[] args) {
        hello he = new hello();
        Thread h1 = new Thread(he);
        Thread h2 = new Thread(he);
        Thread h3 = new Thread(he);
        h1.start();        h2.start();        h3.start();    }     private int count = 5;
}

【运行结果】（每秒输出一个）

5

4

3

2

1

提醒一下，当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁。

当然了，关于多线程，肯定不止这些东西，下面是我整理收藏的关于多线程的面试学习视频文档，有需要的朋友，可以关注+转发后，私信“资料”即可获取

另外还有多线程+高并发+设计模式+网络相关项目一并奉上，还不行动

不会多线程？把这20个源码自己执行一遍，你就会明白了

关注公众号：Java架构师联盟，每日更新技术好文

架构师联盟盟主
关注
专栏目录
别翻了，这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析【JVM篇二】
宜春
12-01 5万+
点进文章的盆友不如先来做一道非常常见的面试题，如果你能做出来，可能你早已掌握并理解了java的类加载机制，若结果出乎你的意料，那就很有必要来了解了解java的类加载机制了。代码如下嗯哼？其实上面程序并不是关键，可能真的难不倒各位，不妨做下面一道面试题可好？如果下面这道面试题都做对了，那没错了，这篇文章你就不用看了，真的。
面试官：线程崩了，为什么不会导致 JVM 崩溃呢？如果是主线程呢？
m0_71777195的博客
07-05 487
网上看到一个很有意思的美团面试题：为什么线程崩溃崩溃不会导致 JVM 崩溃，这个问题我看了不少回答，但发现都没答到根上，所以决定答一答，相信大家看完肯定会有收获，本文分以下几节来探讨：线程崩溃，进程一定会崩溃吗进程是如何崩溃的-信号机制简介为什么在 JVM 中线程崩溃不会导致 JVM 进程崩溃openJDK 源码解析主线程异常会导致 JVM 退出？一般来说如果线程是因为非法访问内存引起的崩溃，那么进程肯定会崩溃，为什么系统要让进程崩溃呢，这主要是因为在进程中，各个线程的地址空间是共享的，既然是共享，那么某个
多线程（源码）
05-07
多线程的源码，易语言生成。写易语言经常用到多线程这个源码。这个就是。
java多线程
我的编程日记
01-11 67
  在java中要想实现多线程，有两种方法，一种是继续Thread类，另外一种是实现Runable接口。1.直接继承Thread的类，代码如下： class 类名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } } 例子1： class hello extends Thread { ...
Java多线程机制（狂神版，附源代码）
LSP522的博客
05-16 613
Java体系的一个重要部分就是多线程。在JAVA程序中，线程的最普遍用途是允许Applet在接受用户输入的同时，在屏幕的另一部分显示动画。使用多线程可以编写出CPU最大利用率的高效程序，因为空闲时间保持最低。这对Java运行的交互式的网络互连环境是至关重要的。 package Thread; import java.awt.*; import java.awt.event.*; import java.applet.*; public class Counter1 extends App
java中的多线程实例
09-04 421
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。 对于直接继承Thread的类来说，代码大致框架是： view sourceprint? 01    class 类名 extends Thread{ 02    方法
多线程编程示例源代码
07-27
多线程编程示例代码，包含CreateThread _beginthread AFXbeginThread 3个API的示例
java 多线程详解（持续更新）
Ferao的博客
05-28 2763
目录 认识cpu、核心与线程 java多线程系列（一）之java多线程技能 认识cpu、核心与线程 cpu与核心 物理核 物理核数量=cpu数(机子上装的cpu的数量)*每个cpu的核心数 虚拟核 ● 所谓的4核8线程，4核指的是物理核心。通过超线程技术，用一个物理核模拟两个虚拟核，每个核两个线程，总数为8线程。 ● 在操作系统看来是8个核，但是实际上是4个物理核。 ● 通过超线程技术可以实现单个物理核实现线程级别的并行计算，但是比不上性能两个物理核。 单核cpu和多核cpu
线程崩了，为什么不会导致 JVM 崩溃呢？如果是主线程呢？
JavaMonsterr的博客
07-25 378
那么线程崩溃后，进程是如何崩溃的呢，这背后的机制到底是怎样的，答案是信号，大家想想要干掉一个正在运行的进程是不是经常用kill-9pid这样的命令，这里的kill其实就是给指定pid发送终止信号的意思，其中的9就是信号，其实信号有很多类型的，在Linux中可以通过kill-l查看所有可用的信号。......
【java面试经(架构师&设计师)-第5课】JAVA基础之多线程(一)
金和弦的博客
11-04 425
技术清单 申明：本文属于整理加工原创，部分举证材料来自于网络，仅用于学习参考。 本文主要介绍java数据结构相关知识，通过本文讲解，你可以明白： 1、JDK、JRE、JVM的概念和区别是什么？ 2、Java程序编译和运行的过程，JVM如何加载字节码文件的，类加载器如何卸载字节码？ 3、JVM内存模型是怎样的？Java运行时数据区情况？一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法？ 4、堆和栈的区别是什么？在java内存分配中，什么时候会存到堆，
多线程实现源代码（简单）
04-20
可以了解多线程之间是怎么运行的。下面的程序验证两个纯程的执行是同时执行的，在单处理器系统上，线程的同时执行需要CPU在线程之间的快速切换来实现。
java thread 源代码_Java多线程学习（一）——Thread类源码
weixin_35102377的博客
02-13 278
概述创建线程的方法常用的有两种，一个是继承Thread类，另一个是实现Runnable接口，然后用Runnable对象创建Thread类。所以在日常使用过程中，不可避免的使用Thread类，本文通过查看Thread类源码的方式，查看Thread类的方法，以及方法的实现原理。构造方法自己阅读源码的方式通常是从构造方法看起，里面会进行一些成员变量的初始化，有些是值得注意的。无参构造为什么默认的线程名会...
多线程源代码测试
momocsdn
03-12 1204
public class ThreadTest { public static void main(String[] args) { // TODO Auto-generated method stub Thread ra1=new ThreadA();//利用多态实例化一个ThreadA对象 Runnable ra2=new ThreadB();//利用多态实例化一个T
多线程，内附所有源代码和概念
m0_52563687的博客
05-03 298
多线程 ​ 学习多线程之前，我们需要了解什么是线程。但是我们在学习线程之前，还得了解什么是进程，因为线程是依赖于进程存在。 1.进程 ​ 通过任务管理器我们可以观察到进程的存在，并且我们发现，只有在程序运行的时候，任务管理器中才能查看到相应的进程。 **概述：**正在运行的程序就是进程。进程是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源。 多进程的意义： ​ 单进程的计算机只能做一个工作，而我们现在用的计算机都是多进程
不会吧，连Java 多线程线程安全都还没搞明白，难怪你面试总不过
QAQFyl的博客
07-24 183
什么是线程安全？ 当一个线程在同一时刻共享同一个全局变量或静态变量时，可能会受到其他线程的干扰，导致数据有问题，这种现象就叫线程安全问题。 为什么有线程安全问题？ 当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题，但是做读操作时不会发生数据冲突问题。 线程安全解决办法？ 1、如何解决多线程之间线程安全问题？ 答：使用多线程之间同步synchronized或使用锁(lock) 2、为什么使用线程同步或使用锁能解决线程安全问题呢？ 答：将可能
多线程学不会？那是因为你没看这篇文章（一）
SnailEater
04-01 390
多线程学不会？那是因为你没看这篇文章！ 在现实生活中，我们就可以把每一个人看作一个线程，当多个人一起工作，就是多线程。
多线程万字源码解析之并发编程
藤井大叔的博客
07-19 231
多线程终结篇温故知新实现线程的两种方式（Thread类与Runnable接口）Thread与Runnable之间区别Thread与Runnable创建线程的弊端Callable接口Future接口FutureTask类ThreadGroup(线程组)线程的优先级线程状态操作系统Java多线程状态之间的转换Thread.join()方法Object.wait()方法Thread.sleep(long)方法Object.wait(long)方法Thread.join(long)线程中断锁之间同步 温故知新 在之
你对多线程了解多少？不会多线程怎么吊打面试官呢？这是不能掉链子的地方~
如果频繁就私信一下呢
07-22 100
多线程的相关概念 1.进程：是操作系统结构的基础；是一个正在执行的程序；计算机中正在运行的程序实例；可以分配给处理器并由处理器执行的一个实体；由单一顺序的执行显示，一个当前状态和一组相关的系统资源所描述的活动单元。 2.线程：线程是程序中一个单一的顺序控制流程。是程序执行流的最小单元。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中
c#使用一个多线程执行一个方法多遍
最新发布
05-19
这样就可以实现多线程执行一个方法多遍。 下面是一个示例代码，其中`DoWork()`方法是需要多线程执行的方法，`numOfLoops`表示需要执行的次数。 ```csharp int numOfLoops = 10; List<Task> tasks = new List(); ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值