多线程相关实例（多线程经典应用场景）

最新推荐文章于 2023-08-25 16:20:57 发布
最新推荐文章于 2023-08-25 16:20:57 发布
阅读量1.8w 收藏 222
点赞数 29
分类专栏： 笔记 文章标签： 多线程 java

转载，from 网络，未能找到原创人员，只找到一个转载 https://blog.csdn.net/u013521220/article/details/79648270

多线程实例目录

相关知识：

Java多线程程序涉及到的知识：

（一）对同一个数量进行操作

（二）对同一个对象进行操作

（三）回调方法使用

（四）线程同步，死锁问题

（五）线程通信

等等

经典案例一：三个售票窗口共同出售20张票

程序分析：
1.票数要使用同一个静态值
2.为保证不会出现卖出同一个票数，要java多线程同步锁。

设计思路：
1.创建一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操作！售票要使用同步锁：即有一个站台卖这张票时，其他站台要等这张票卖完！
2.创建主方法调用类

（一）创建一个站台类，继承Thread


package com.xykj.threadStation;  
   
public class Station extends Thread {  
   
        // 通过构造方法给线程名字赋值  
        public Station(String name) {  
             super(name);// 给线程名字赋值  
        }  
           
        // 为了保持票数的一致，票数要静态  
        static int tick = 20;  
           
        // 创建一个静态钥匙  
        static Object ob = "aa";//值是任意的  
           
        // 重写run方法，实现买票操作  
        @Override  
        public void run() {  
            while (tick > 0) {  
                synchronized (ob) {// 这个很重要，必须使用一个锁，  
                    // 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来  
                    if (tick > 0) {  
                        System.out.println(getName() + "卖出了第" + tick + "张票");  
                        tick--;  
                    } else {  
                        System.out.println("票卖完了");  
                    }  
                }  
                try {  
                     sleep(1000)；//休息一秒  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
               
            }  
    }  
   
}

（二）创建主方法调用类

package com.xykj.threadStation;  
   
public class MainClass {  
    /**  
     * java多线程同步锁的使用  
     * 示例：三个售票窗口同时出售10张票  
     * */  
    public static void main(String[] args) {  
        //实例化站台对象，并为每一个站台取名字  
         Station station1=new Station("窗口1");  
         Station station2=new Station("窗口2");  
         Station station3=new Station("窗口3");  
       
        // 让每一个站台对象各自开始工作  
         station1.start();  
         station2.start();  
         station3.start();  
       
    }  
   
}

程序运行结果：
运行结果
可以看到票数是不会有错的！

经典案例二：AB两人共用一个账户，A在柜台取钱，B在ATM机取钱！

程序分析：
钱的数量要设置成一个静态的变量。两个人要取的同一个对象值

（一）创建一个Bank类

[plain] view plain copy

package com.xykj.bank;

public class Bank {

// 假设一个账户有1000块钱  
static int money = 1000;  
   
// 柜台Counter取钱的方法  
public void Counter(int money) {// 参数是每次取走的钱  
    Bank.money -= money;//取钱后总数减少  
    System.out.println("A取走了" + money + "还剩下" + (Bank.money));  
}  
   
// ATM取钱的方法  
public void ATM(int money) {// 参数是每次取走的钱  
    Bank.money -= money;//取钱后总数减少  
    System.out.println("B取走了" + money + "还剩下" + (Bank.money));  
}

}

（二）创建一个PersonA类

[plain] view plain copy

package com.xykj.bank;

public class PersonA extends Thread {
// 创建银行对象
Bank bank;

// 通过构造器传入银行对象，确保两个人进入的是一个银行  
public PersonA(Bank bank) {  
     this.bank = bank;  
}  
  
//重写run方法，在里面实现使用柜台取钱  
@Override  
    public void run() {  
        while (Bank.money >= 100) {  
            bank.Counter(100);// 每次取100块  
        try {  
            sleep(100);// 取完休息0.1秒  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

}

（三）创建一个PersonB类

[plain] view plain copy

package com.xykj.bank;

public class PersonB extends Thread {
// 创建银行对象
Bank bank;

// 通过构造器传入银行对象，确保两个人进入的是一个银行  
public PersonB(Bank bank) {  
    this.bank = bank;  
}  
   
// 重写run方法，在里面实现使用柜台取钱  
@Override  
public void run() {  
    while (Bank.money >= 200) {  
        bank.ATM(200);// 每次取200块  
        try {  
            sleep(100);// 取完休息0.1秒  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
       
}

}

（四）创建主方法的调用类

[plain] view plain copy

package com.xykj.bank;

public class MainClass {
/**
* 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
* */
public static void main(String[] args) {
// 实力化一个银行对象
Bank bank = new Bank();
// 实例化两个人，传入同一个银行的对象
PersonA pA = new PersonA(bank);
PersonB pB = new PersonB(bank);
// 两个人开始取钱
pA.start();
pB.start();

}

}

运行结果：

可以看到取完就停止运行了。

四．示例三：龟兔赛跑问题

龟兔赛跑：20米 //只要为了看到效果，所有距离缩短了

要求：

1.兔子每秒0.5米的速度，每跑2米休息10秒，

2.乌龟每秒跑0.1米，不休息

3.其中一个跑到终点后另一个不跑了！

   程序设计思路：

1.创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

2.创建Rabbit兔子类和Tortoise乌龟类，继承动物类

3.两个子类重写running方法

4.本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象

（一）创建Animal动物类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public abstract class Animal extends Thread{

public double length=20;//比赛的长度  
  
public abstract void runing();//抽象方法需要子类实现  
  
//在父类重写run方法，在子类只要重写running方法就可以了  
@Override  
public void run() {  
    super.run();  
    while (length>0) {  
         runing();  
    }  
}  
  
//在需要回调数据的地方（两个子类需要），声明一个接口  
public static interface Calltoback{  
    public void win();  
}  
  
//2.创建接口对象  
public Calltoback calltoback;

}

（二）创建Rabbit兔子类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class Rabbit extends Animal {

public Rabbit() {  
    setName("兔子");// Thread的方法，给线程赋值名字  
}  
   
// 重写running方法，编写兔子的奔跑操作  
@Override  
public void runing() {  
    // 跑的距离  
    double dis = 0.5;  
    length -= dis;//跑完后距离减少  
    if (length <= 0) {  
        length = 0;  
        System.out.println("兔子获得了胜利");  
        //给回调对象赋值，让乌龟不要再跑了  
        if (calltoback != null) {  
            calltoback.win();  
        }  
    }  
    System.out.println("兔子跑了" + dis + "米，距离终点还有" + (int)length + "米");  
       
    if (length % 2 == 0) {// 两米休息一次  
        try {  
            sleep(1000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

}

（三）创建Tortoise乌龟类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class Tortoise extends Animal {

public Tortoise() {  
    setName("乌龟");// Thread的方法，给线程赋值名字  
}  
   
// 重写running方法，编写乌龟的奔跑操作  
@Override  
public void runing() {  
    // 跑的距离  
    double dis = 0.1;  
    length -= dis;  
    if (length <= 0) {  
        length = 0;  
        System.out.println("乌龟获得了胜利");  
        // 让兔子不要在跑了  
        if (calltoback != null) {  
            calltoback.win();  
        }  
    }  
    System.out.println("乌龟跑了" + dis + "米，距离终点还有" + (int) length + "米");  
    try {  
        sleep(100);  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
}

}

（四）创建一个让动物线程停止的类，这里要实现回调接口

[plain] view plain copy

package com.xykj.rabbit_tortoise;

import com.xykj.rabbit_tortoise.Animal.Calltoback;

public class LetOneStop implements Calltoback {

// 动物对象  
Animal an;  
  
// 获取动物对象，可以传入兔子或乌龟的实例  
public LetOneStop(Animal an) {  
    this.an = an;  
}  
  
//让动物的线程停止  
@Override  
public void win() {  
    // 线程停止  
    an.stop();  
}

}

（五）创建一个主方法调用类，

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class MainClass {
/**
* 龟兔赛跑：20米
* */
public static void main(String[] args) {
//实例化乌龟和兔子
Tortoise tortoise = new Tortoise();
Rabbit rabbit = new Rabbit();
//回调方法的使用，谁先调用calltoback方法，另一个就不跑了
LetOneStop letOneStop1 = new LetOneStop(tortoise);
rabbit.calltoback = letOneStop1;//让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
LetOneStop letOneStop2 = new LetOneStop(rabbit);
tortoise.calltoback = letOneStop2;//让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
//开始跑
tortoise.start();
rabbit.start();

}

}

运行结果：

可以看到结果兔子赢了。

一般来说兔子获得了胜利是在最后输出的，

但是，由于线程一直在执行所以会出现：

“兔子跑了0.5米，距离终点还有0米”还没来得及输出完，

而“兔子获得了胜利”已经输出完毕了。

五．实例四:

在一个KFC内，服务员负责生产食物，消费者负责消费食物；

当生产到一定数量可以休息一下，直到消费完食物，再马上生产，一直循环

程序涉及到的内容：

1.这设计到java模式思想：生产者消费者模式

2.要保证操作对象的统一性，即消费者和服务者都是跟同一个KFC发生关系的，KFC只能new一次

3.this.notifyAll();和 this.wait();一个是所有唤醒的意思，一个是让自己等待的意思；

比如本题中，生产者生产完毕后，先所有唤醒（包括消费者和生产者），再让所有自己（生产者）等待

这时，消费者开始消费，直到食材不够，先所有唤醒（包括消费者和生产者），再让所有自己（消费者）等待

一直执行上面的操作的循环

4.生产者和消费者都要继承Thread，才能实现多线程的启动

程序设计的步骤思路：

1.创建一个食物类Food，有存放/获取食物的名称的方法

2.创建一个KFC类，有生产食物和消费食物的方法

3.创建一个客户类Customer，继承Thread，重写run方法，在run方法里面进行消费食物操作

4.创建一个服务员类Waiter，继承Thread，重写run方法，在run方法里面进行生产食物的操作

5.创建主方法的调用类

（一）创建一个食物类Food

[plain] view plain copy

package com.xykj.producer_consumer;

public class Food {
String name="";
//通过构造方法传入食物的名字
public Food(String name) {
this.name=name;
}
//get、set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

（二）创建一个KFC类

[plain] view plain copy

package com.xykj.producer_consumer;
import java.util.ArrayList;
import java.util.List;

public class KFC {

//食物的种类  
String[] names = { "薯条", "烧板", "鸡翅", "可乐" };  
  
//生产的最大值，到达后可以休息  
static final int Max = 20;  
  
//存放食物的集合  
List<food> foods = new ArrayList<food>();  
   
// 生产食物的方法  
public void prod(int index) {  
    synchronized (this) {  
        // 如果食物数量大于20  
        while (foods.size() > Max) {  
            System.out.println("食材够了");  
            this.notifyAll();//这个唤醒是针对生产者和消费者，有all  
            try {  
                String name=Thread.currentThread().getName();  
                this.wait();//这个唤醒是针对生产者，没有all  
                System.out.println("生产者："+name);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
           
        // 开始生产食物食物//有一点要注意的  
        System.out.println("开始生产食物");  
        for (int i = 0; i < index; i++) {  
            Food food = new Food(names[(int) (Math.random() * 4)]);  
            foods.add(food);  
            System.out.println("生产了" + food.getName() + foods.size());  
        }  
    }  
}  
   
// 消费食物的方法  
public void consu(int index) {   
    synchronized (this) {  
        while (foods.size() < index) {  
            System.out.println("食材不够了");  
            this.notifyAll();//这个唤醒是针对生产者和消费者，有all  
            try {  
                String name=Thread.currentThread().getName();  
                this.wait();//这个唤醒是针对消费者，没有all  
                System.out.println("消费者："+name);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        // 足够消费  
        System.out.println("开始消费");  
        for (int i = 0; i < index; i++) {  
            Food food = foods.remove(foods.size() - 1);  
            System.out.println("消费了一个" + food.getName() + foods.size());  
        }  
    }  
}

}

（三）创建一个客户类Customer

[plain] view plain copy

package com.xykj.producer_consumer;

public class Customers extends Thread{
KFC kfc;
//KFC要传入，保证每一个服务员和用户在同一个KFC对象内
public Customers(KFC kfc) {
this.kfc=kfc;
}
@Override
public void run() {
int size=(int)(Math.random()*5);//每次要消费的食物的数量
while (true) {
kfc.consu(size);//在消费的方法里面传入参数
}

}

}

（四）创建一个服务员类Waiter

[plain] view plain copy

package com.xykj.producer_consumer;

public class Waiter extends Thread{
KFC kfc;
//KFC要传入，保证每一个服务员和用户在同一个KFC对象内
public Waiter(KFC kfc) {
this.kfc=kfc;
}
@Override
public void run() {
int size=(int)(Math.random()*5)+5;//每次生产的数量
while (true) {
kfc.prod(size);//传入每次生产的数量
}

}

}

（五）创建主方法的调用类

[plain] view plain copy

package com.xykj.producer_consumer;

public class MainClass {
/**
* 生产者消费者模式
*
* */
public static void main(String[] args) {

    // 只实例化一个KFC对象，保证每一个服务员和用户在同一个KFC对象内  
    KFC kfc = new KFC();  
      
    //实例化4个客户对象  
    Customers c1 = new Customers(kfc);  
    Customers c2 = new Customers(kfc);  
    Customers c3 = new Customers(kfc);  
    Customers c4 = new Customers(kfc);  
      
    //实例化3个服务员对象  
    Waiter waiter1 = new Waiter(kfc);  
    Waiter waiter2 = new Waiter(kfc);  
    Waiter waiter3 = new Waiter(kfc);  
      
    //让所有的对象的线程都开始工作  
    waiter1.start();  
    waiter2.start();  
    waiter3.start();  
    c1.start();  
    c2.start();  
    c3.start();  
    c4.start();  
}

}

六．示例五：设计四个线程对象对同一个数据进行操作，

两个线程执行减操作，两个线程执行加操作。

程序分析：1.创建一个ThreadAddSub类继承Thread，重写run方法

2.在run方法里面实现加和减的操作，每次操作后睡眠1秒

3.创建主方法调用类

（一）创建一个ThreadAddSub类

[plain] view plain copy

package com.xykj.add;

public class ThreadAddSub extends Thread {
//判断要进行的操作
boolean operate = true;
//要操作的数
static int sum = 0;

// 把操作运算通过构造方法传进来  
public ThreadAddSub(boolean operate) {  
    super();  
    this.operate = operate;  
}  
   
@Override  
public void run() {  
    super.run();  
    while (true) {  
        if (operate) {  
            sum+=5;  
            System.out.println("加后，sum="+sum);  
        } else {  
            sum-=4;  
            System.out.println("减后，sum="+sum);  
        }  
        try {  
            sleep(500);// 睡眠0.5秒  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
   
}

}

（二）创建主方法调用类

[plain] view plain copy

emptypackage com.xykj.add;

public class MainClass {
/**
* (线程同步)
* */
public static void main(String[] args) {

    //创建一个存放ThreadAddSub对象的数组  
    ThreadAddSub[] tSub=new ThreadAddSub[4];  
    for (int i = 0; i < tSub.length; i++) {  
      
    //把实例化ThreadAddSub对象赋值到数组内  
    //第一三个是true，二四个是false  
    tSub[i]=new ThreadAddSub(i%2==0?true:false);  
      
    //让线程开始工作  
    tSub[i].start();  
    }  
   
}

}

线程示例总结：

代码块锁是一个防止数据发生错误的一个重要手段。

对象的统一性是非常重要的，这要想到对象的传入问题，

要操作的对象只能new一次，其他的操作都是对这个传入的对象进行的，

才能保证数据一致性，完整性和正确性。

练习题目：

  1. （多线程）代码实现火车站4个卖票窗口同时买票的场景，输出示例：
    窗口1卖票
    窗口2卖票
    窗口1卖票
    …
  2. （线程同步）代码实现火车站4个窗口同时卖100张票的代码逻辑，同一个窗口不能卖同一
    张张票。
  3. （线程通信）小明打算去提款机上取钱，发现卡上没钱，这时候他告知妈妈去存钱，妈妈
    存了钱了，告知小明存好了可以取钱了。(PS:小明分多次取钱，每次取100，当发现钱不够
    100，就等待妈妈存钱，小明他妈每次存2000，当发现钱小于100就存钱，就存钱，并且
    通知小明去取钱，当大于100就等待小明钱不够是再存)
  4. (线程同步)设计四个线程对象对同一个数据进行操作，两个线程执行减操作，两个线程执行
    加操作。
  5. （线程通信）制作两个线程对象，要求用同步块的方式使第一个线程运行2次，然后将自己
    阻塞起来，唤醒第二个线程，第二个线程再运行2次，然后将自己阻塞起来，唤醒第一个线
    程……两个线程交替执行。
  6. （线程同步）设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。
  7. （线程通信）子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着
    再回到主线程又循环100，如此循环50次。
瞎琢磨先生
关注
  • 29
    点赞
  • 踩
  • 222
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Spring Boot如何优雅的使用多线程实例详解
08-19
主要给大家介绍了关于Spring Boot如何优雅的使用多线程的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring Boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
最全多线程四大经典案例及java多线程的实现_java 多线程经典案例，2024年最新简直无敌
2401_84976040的博客
05-16 252
if(curTime
多线程使用场景
weixin_43412919的博客
09-15 8057
工作当中多线程的使用场景总结
实际场景中的多线程并发编程案例
iNiBuBian的博客
12-06 7041
一、CountDownLatch CountDownLatch的用法 CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继
多线程应用场景
weixin_43751710的博客
05-29 1759
总结一下多线程的应用场景： 1、socket（套接字、输入输出流） 2、定时任务（job、timertask） 3、多连接同时下载 4、Web网络爬虫（输入输出流、正则表达式） 5、Dao层连接数据库时，一般也用一个线程池来构造一个连接池（可以用到Threadlocal） 6、Web的Servlet其实也是被多线程访问的，只是被封装起来了，感觉不到而已 7、GUI程序中的异步响应，比如进度条，就是...
多线程的使用场景有哪些？
m0_57313444的博客
08-25 1316
2.为了更快的速度。主线程专用于监控请求，子线程专用于处理请求，可以实现大吞吐量。4.当某个任务比较耗时但不消耗CPU时，开启多线程会显着提升效率。3.虽然是低优先级的服务，但需要时不时做。比如JVM垃圾回收。7.向数据库中插入大量数据，使用适当数量的线程。6.FTP下载，多线程文件操作。1.不阻塞主线程(UI线程)
Python 多线程实例详解
09-21
在实际应用中，Python的多线程更适合处理I/O密集型任务，如网络请求、文件读写等，因为在这些操作中，Python解释器会释放GIL，允许其他线程执行。在上面的示例中，虽然压缩文件是一个计算密集型任务，但由于`zipfile...
Linux下的多线程编程实例解析
01-20
　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就...
C#队列Queue多线程用法实例
09-03
队列在多线程环境下常常用于任务调度、消息传递等场景，因为它们能有效地管理和同步数据访问。本实例将详细讲解如何在多线程中使用C#的Queue类。 首先，我们创建一个队列实例，通过`new Queue()`来指定存储的数据...
Python多线程及其基本使用方法实例分析
09-18
Python的多线程是编程中实现并发执行任务的重要机制，尤其在处理大量数据或需要同时进行多种操作的场景中。然而，Python的多线程在实际应用中有一些独特的限制，这些都源于Python的全局解释器锁（GIL，Global ...
多线程的应用场景
weixin_45531476的博客
05-21 7574
通俗的解释一下多线程先： 多线程用于堆积处理，就像一个大土堆，一个推土机很慢，那么10个推土机一起来处理，当然速度就快了，不过由于位置的限制，如果20个推土机，那么推土机之间会产生相互的避让，相互摩擦，相互拥挤，反而不如10个处理的好，所以，多线程处理，线程数要开的恰当，就可以提高效率。 多线程使用的目的： 1、 吞吐量：做WEB，容器帮你做了多线程，但是它只能帮你做请求层面的，简单的说，就是一个请求一个线程(如struts2，是多线程的，每个客户端请求创建一个实例，保证线程安全)，或多个请求一个线程，如
多线程在项目中的应用
qq_45243783的博客
04-09 8431
1.发短信 发短信的场景有很多，比如手机号+验证码登录注册，电影票买完之后会发送取票码，发货之后会有物流信息，支付之后银行发的付款信息，电力系统的电费预警信息等等 在这些业务场景中，有一个特征，那就是主业务可以和短信业务割裂，比如手机号+验证码登陆，当我们点击获取验证码的时候，会连接短信业务平台发送短信，但是发短信这个业务受到短信平台的影响，可能会存在一定时间的延时，但是我们不一定非要等短信平台返回之后，再给用户返回，我们可以先返回获取验证码成功的提升样式，将发短信的业务放入到另外一个线程中执行，用户晚一会
多线程的实际应用场景
热门推荐
cmd_dir的博客
12-07 1万+
业务场景 我们公司做的是加油业务，用户可以在app上通过当前位置和目标位置来查询地图路线以及路线途径的所有加油站，路线查询会调用高德地图提供的接口，途径油站则根据返回的路线信息进行查询，所以当用户输入起始位置和目标位置点击查询后会做以下几步操作： 调用高德地图接口获取路线 根据高德地图返回的路线信息去查询途径的所有油站 问题点 公司发展很快，入驻平台的油站很多，当用户输入的起始地和目标地距离很远时，那么途径油站的数量会很大，单独采取普通查询库的方式会很耗时，并且途径油站的数据必须是实时的，所以无法使用缓
多线程的使用场景及运用
qq_40230608的博客
08-07 1214
多线程
JAVA多线程和并发基础面试题
dawuafang
05-23 654
多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。在这里，从面试的角度列出了大部分重要的问题，但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。（校对注：非常赞同这个观点） Java多线程面试问题 1. 进程和线程之间有什么不同？ 一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执...
多线程相关实例
ZJRUIII的博客
03-18 2414
文章目录一、多线程案例1.单例模式1.1 饿汉模式 一、多线程案例 1.单例模式 单例模式是一种常见的“设计模式”。在软件开发中，涉及到的场景有很多，变化也有很多。很多新手如果不加限制的乱去开发，此时会造成的麻烦会有很多。于是有很多强者就把一些常见场景的一些常见解决方案整理成一份“谱”，如果按照这个谱去开发，那么开发的代码不会差到哪里去。“谱”指的就是设计模式。 场景：代码中的有些概念，不应该存在多个实例，此时应该使用单例模式来解决。例如MySQL中的DataSource类，在一个程序中就应该只有一个实例，
.net多线程应用实例
最新发布
06-16
以下是一个简单的.NET多线程应用实例，使用C#的Task和Thread类： ```csharp using System; using System.Threading.Tasks; public class Worker { private static string data = "Hello, this is a message."; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值