Ｃ＃多线程编程

最新推荐文章于 2024-11-11 10:46:55 发布
最新推荐文章于 2024-11-11 10:46:55 发布
阅读量621 收藏 2
点赞数
分类专栏： C# 多线程 文章标签： 多线程 编程 object thread download locking
C# 同时被 2 个专栏收录
18 篇文章 0 订阅
订阅专栏
多线程
11 篇文章 0 订阅
订阅专栏
//一个简单的示例
// HelloWordThread.cs // ------------------------using System;
using  System.Threading;

 public   class  Test
 {
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Console.WriteLine ("Main thread: {0}", i);
            Thread.Sleep(1000);
        }
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 10; i++)
        {
            Console.WriteLine ("Other thread: {0}", i);
            Thread.Sleep(500);
        }
    }
} 结果：
Main thread:  0
Other thread:  0
Other thread:  1
Main thread:  1
Other thread:  2
Other thread:  3
Main thread:  2
Other thread:  4
Other thread:  5
Main thread:  3
Other thread:  6
Other thread:  7
Main thread:  4
Other thread:  8
Other thread:  9  
 // UsingDelegate.cs
------------------------------------
using  System;
 using  System.Threading;

 public   class  Test
 {
    static void Main()
    {
        Counter foo = new Counter();
        ThreadStart job = new ThreadStart(foo.Count);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Console.WriteLine ("Main thread: {0}", i);
            Thread.Sleep(1000);
        }
    }
}

public   class  Counter
 {
    public void Count()
    {
        for (int i=0; i < 10; i++) { Console.WriteLine ("Other thread: {0}", i);
            Thread.Sleep(500);
        }
    }
} 

二、线程中的参数传递
使用类、类的方法或类的属性都可以向线程传递参数：
public class UrlDownloader
{ string url; public UrlDownloader ( string url) { this.url = url; } public void Download() {
WebClient wc = new WebClient();
Console.WriteLine("Downloading " + url); byte[] buffer = wc.DownloadData (url); string download = Encoding.ASCII.GetString(buffer); Console.WriteLine(download); Console.WriteLine("Download successful.");
//这里你可以将download进行保存等处理...... } } [... 在另一个类中使用它们...] UrlDownloader downloader = new UrlDownloader (yourUrl); new Thread ( new ThreadStart (downloader.Download)).Start(); 
注意参数是如何传递的。
在.NET 2.0中还可以这样：
(CODE-BESIDE）
方式一：
ThreadStart starter = delegate { Download(yourUrl); });
new Thread(starter).Start();
//使用线程池

WaitCallback callback = delegate (object state) { Download ((string)state); };
ThreadPool.QueueUserWorkItem (callback, yourUrl);



方式二(使用ParameterizedThreadStart)：


Thread t = new Thread (new ParameterizedThreadStart(DownloadUrl));
t.Start (myUrl);

static void DownloadUrl(object url)
{
    // ....
}

 三、线程内部是如何进行的？

看一下以下两个例子的运行结果：

 
 

  
  

   
   
   
   //
   
   TestThread.csusing System;
   
   

   
   using
   
    System.Threading;


   
   public
   
    
   
   class
   
    Test

   
   
   
   {
    static int count=0;
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            count++;
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            count++;
        }
    }
}
   
    
  
  

 
 
   

 
 

  
  

   
   
   
   //
   
   InnerDataThread.csusing System;
   
   

   
   using
   
    System.Threading;


   
   public
   
    
   
   class
   
    Test

   
   
   
   {
    static int count=0;
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            int tmp = count;
            Console.WriteLine ("Read count={0}", tmp);
            Thread.Sleep(50);
            tmp++;
            Console.WriteLine ("Incremented tmp to {0}", tmp);
            Thread.Sleep(20);
            count = tmp;
            Console.WriteLine ("Written count={0}", tmp);
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            int tmp = count;
            Console.WriteLine (" Read count={0}", tmp);
            Thread.Sleep(20);
            tmp++;
            Console.WriteLine (" Incremented tmp to {0}", tmp);
            Thread.Sleep(10);
            count = tmp;
            Console.WriteLine (" Written count={0}", tmp);
            Thread.Sleep(40);
        }
    }
}
   
   

  
  

 
 
  
  
Read count=0
                                Read count=0
                                Incremented tmp to 1
                                Written count=1
Incremented tmp to 1
Written count=1
                                Read count=1
                                Incremented tmp to 2
Read count=1
                                Written count=2
                                Read count=2
Incremented tmp to 2
                                Incremented tmp to 3
Written count=2
                                Written count=3
Read count=3
                                Read count=3
Incremented tmp to 4
                                Incremented tmp to 4
                                Written count=4
Written count=4
                                Read count=4
Read count=4
                                Incremented tmp to 5
                                Written count=5
Incremented tmp to 5
Written count=5
Read count=5
Incremented tmp to 6
Written count=6
Final count: 6

再比较下面这个例子：

 

// 使用Monitor.Enter/Exit 
 // MonitorThread.cs

using  System;
 using  System.Threading;

 public   class  Test
 {
    static int count=0;
    static readonly object countLock = new object();
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            Monitor.Enter(countLock);
            int tmp = count;
            Console.WriteLine ("Read count={0}", tmp);
            Thread.Sleep(50);
            tmp++;
            Console.WriteLine ("Incremented tmp to {0}", tmp);
            Thread.Sleep(20);
            count = tmp;
            Console.WriteLine ("Written count={0}", tmp);
            Monitor.Exit(countLock);
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            Monitor.Enter(countLock);
            int tmp = count;
            Console.WriteLine (" Read count={0}", tmp);
            Thread.Sleep(20);
            tmp++;
            Console.WriteLine (" Incremented tmp to {0}", tmp);
            Thread.Sleep(10);
            count = tmp;
            Console.WriteLine (" Written count={0}", tmp);
            Monitor.Exit(countLock);
            Thread.Sleep(40);
        }
    }
}


结果与上例InnerDataThread.cs是不一样的，原因就在于Monitor的使用了。

Read count=0
Incremented tmp to 1
Written count=1
                                Read count=1
                                Incremented tmp to 2
                                Written count=2
Read count=2
Incremented tmp to 3
Written count=3
                                Read count=3
                                Incremented tmp to 4
                                Written count=4
Read count=4
Incremented tmp to 5
Written count=5
                                Read count=5
                                Incremented tmp to 6
                                Written count=6
Read count=6
Incremented tmp to 7
Written count=7
                                Read count=7
                                Incremented tmp to 8
                                Written count=8
Read count=8
Incremented tmp to 9
Written count=9
                                Read count=9
                                Incremented tmp to 10
                                Written count=10
Final count: 10

下面使用lock来锁定线程：

//  LockThread.cs
using  System;
 using  System.Threading;

 public   class  Test
 {
    static int count=0;
    static readonly object countLock = new object();
    
    static void Main()
    {
        ThreadStart job = new ThreadStart(ThreadJob);
        Thread thread = new Thread(job);
        thread.Start();
        
        for (int i=0; i < 5; i++)
        {
            lock (countLock)
            {
                int tmp = count;
                Console.WriteLine ("Read count={0}", tmp);
                Thread.Sleep(50);
                tmp++;
                Console.WriteLine ("Incremented tmp to {0}", tmp);
                Thread.Sleep(20);
                count = tmp;
                Console.WriteLine ("Written count={0}", tmp);
            }
            Thread.Sleep(30);
        }
        
        thread.Join();
        Console.WriteLine ("Final count: {0}", count);
    }
    
    static void ThreadJob()
    {
        for (int i=0; i < 5; i++)
        {
            lock (countLock)
            {
                int tmp = count;
                Console.WriteLine (" Read count={0}", tmp);
                Thread.Sleep(20);
                tmp++;
                Console.WriteLine (" Incremented tmp to {0}", tmp);
                if (count < 100)
                    throw new Exception();
                Thread.Sleep(10);
                count = tmp;
                Console.WriteLine (" Written count={0}", tmp);
            }
            Thread.Sleep(40);
        }
    }
}


结果如何？与MonitorThread.cs比较一下，再想想看。

四、死锁

// DeadLockSample.cs
// 分析一下为什么会发生死锁？

 

using  System;
 using  System.Threading;

 public   class  Test
 {
    static readonly object firstLock = new object();
    static readonly object secondLock = new object();
    
    static void Main()
    {
        new Thread(new ThreadStart(ThreadJob)).Start();
        
        // Wait until we're fairly sure the other thread
        // has grabbed firstLock
        Thread.Sleep(500);
        
        Console.WriteLine ("Locking secondLock");
        lock (secondLock)
        {
            Console.WriteLine ("Locked secondLock");
            Console.WriteLine ("Locking firstLock");
            lock (firstLock)
            {
                Console.WriteLine ("Locked firstLock");
            }
            Console.WriteLine ("Released firstLock");
        }
        Console.WriteLine("Released secondLock");
    }
    
    static void ThreadJob()
    {
        Console.WriteLine (" Locking firstLock");
        lock (firstLock)
        {
            Console.WriteLine(" Locked firstLock");
            // Wait until we're fairly sure the first thread
            // has grabbed secondLock
            Thread.Sleep(1000);
            Console.WriteLine(" Locking secondLock");
            lock (secondLock)
            {
                Console.WriteLine(" Locked secondLock");
            }
            Console.WriteLine (" Released secondLock");
        }
        Console.WriteLine(" Released firstLock");
    }
}

 

 
 
Locking firstLock
Locked firstLock 
Locking secondLock 
Locked secondLock 
Locking firstLock Locking secondLock

因应之道，使用Queue和Monitor:

 

// QueueMonitorThread.cs

using  System;
 using  System.Collections;
 using  System.Threading;

 public   class  Test
 {
    static ProducerConsumer queue;
    
    static void Main()
    {
        queue = new ProducerConsumer();
        new Thread(new ThreadStart(ConsumerJob)).Start();
        
        Random rng = new Random(0);
        for (int i=0; i < 10; i++)
        {
            Console.WriteLine ("Producing {0}", i);
            queue.Produce(i);
            Thread.Sleep(rng.Next(1000));
        }
    }
    
    static void ConsumerJob()
    {
        // Make sure we get a different random seed from the
        // first thread
        Random rng = new Random(1);
        // We happen to know we've only got 10 
        // items to receive
        for (int i=0; i < 10; i++)
        {
            object o = queue.Consume();
            Console.WriteLine (" Consuming {0}", o);
            Thread.Sleep(rng.Next(1000));
        }
    }
}

public   class  ProducerConsumer
 {
    readonly object listLock = new object();
    Queue queue = new Queue();

    public void Produce(object o)
    {
        lock (listLock)
        {
            queue.Enqueue(o);
            if (queue.Count==1)
            {
                Monitor.Pulse(listLock);
            }
        }
    }
    
    public object Consume()
    {
        lock (listLock)
        {
            while (queue.Count==0)
            {
                Monitor.Wait(listLock);
            }
            return queue.Dequeue();
        }
    }
}

 

 
 
Producing 0 Consuming 0
Producing 1 Consuming 1
Producing 2 Consuming 2
Producing 3 Consuming 3
Producing 4
Producing 5 Consuming 4
Producing 6 Consuming 5
                                         Consuming 6
Producing 7 Consuming 7
Producing 8 Consuming 8
Producing 9 Consuming 9
solond
关注
专栏目录
多线程编程
03-07
基础的多线程编程
C#多线程编程实战 源代码
12-06
本书是一本通俗易懂的C#多线程编程指南，通过70多个容易理解的示例，循序渐进地讲解C#5.0中的异步及并发编程，引导读者了解Windows下C#多线程编程的多样性。 通过阅读本书，你将学到： 使用原始线程、异步线程，...
C# 多线程编程
最新发布
Y的博客
11-11 827
CSharp 多线程的使用
C#多线程编程
weixin_42647208的博客
02-04 2898
目录1. 多线程描述2. 线程生命周期3. 线程的常用属性与方法4. 线程操作(1) 创建线程(2) 管理线程(3) 销毁线程 1. 多线程描述 线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。在多线程之下可以通过分配线程，同时处理多个任务。 2. 线程生命周期 线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。 下面列出了线程生命周期中的各种状态： 未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。 就绪状
C#多线程编程详细教学
laizhixue的博客
03-29 1681
然而，多线程编程也带来了线程安全和同步的问题，需要使用适当的同步机制来确保数据的一致性和避免线程冲突。在编写多线程程序时，应该仔细考虑线程间的交互和共享资源的访问方式，以确保程序的正确性和性能。在C#中，多线程编程是一种非常重要的技术，它允许程序同时执行多个任务，从而提高了应用程序的响应性和整体性能。一个线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。有时候，简单的lock或Monitor就能满足需求，而在复杂的场景下，可能需要结合多种策略来确保线程安全。
C# 多线程编程：线程锁与无锁并发
吾家有猫名探花的博客
03-28 2437
多线程编程在现代软件开发中至关重要。本文将讨论 C# 中的多线程技术，重点介绍锁的概念，线程锁与无锁并发。通过学习本篇博文，我们将学会如何正确处理并发问题，提高程序的性能和稳定性。锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。本文深入探讨了 C# 中的多线程编程技术，重点介绍了锁的基本概念、线程锁的类型、锁的实现方式、无锁并发编程以及 C# 中的并发集合类和经典并发同步问题。理解多线程编程的基本概念。
C#多线程编程详细教学_c# 创建线程
2401_84969426的博客
05-12 831
在上面的例子中，lockObject是一个私有的对象，用作同步锁。Monitor 类：Monitor类提供了与lock关键字相同的功能，但它是通过方法调用的形式来实现的。注意，在C# 7.1及更高版本中，Main方法可以被声明为async，这使得我们可以方便地在主线程中使用await关键字来等待异步操作。在上面的示例中，我们使用lock关键字来确保在增加sharedCounter时只有一个线程能够访问它。需要注意的是，过度使用线程同步可能会导致性能下降，因此应该谨慎使用，并只在必要时进行同步。
多线程编程，Ｃ＋＋
hunter
11-30 128
    https://www.cnblogs.com/langzou/p/7364014.html https://blog.csdn.net/y396397735/article/details/81008086 https://blog.csdn.net/liuker888/article/details/46848905 https://blog.csdn.net/hitweng...
C#多线程编程实例实战.pdf
10-24
C#多线程编程实例实战 C#多线程编程实例实战是指在C#语言中实现多线程编程的实例和实战经验。多线程编程是指在同一个进程中创建多个线程，以便提高程序的执行效率和响应速度。在C#语言中，可以使用Thread类和线程池...
C#多线程编程实战完整源码
07-16
C#多线程编程是开发高效、响应迅速的软件应用的关键技术之一，尤其在现代计算环境中，多核处理器和并发处理的需求日益增加。本资源"《C#多线程编程实战》完整源码"提供了丰富的实例，适用于学习和实践C#中的多线程...
c#多线程编程实战（原书第二版）源码
06-21
《C#多线程编程实战（原书第二版）源码》是一本深入探讨C#中多线程技术的专业书籍，其源码提供了丰富的实践示例，帮助读者掌握并发编程的核心概念和技术。在C#中，多线程是实现高性能、响应式应用程序的关键组成部分...
C#多线程编程实战.pdf
05-04
C#多线程编程实战.pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值