微雨燕双飞

多线程-同步

本文将涉及如下内容

Wait Handles

EventWaitHandle

Seamphores

Mutex

Critical Sections

Miscellaneous Objects

这篇文章重点说明多个不同的线程之间的同步问题。

WaitHandles

首先，我们必须认识到，当你尝试着理解怎么才能使多个线程在一起协调地很好，最关键的问题是怎样排序这些操作。例如，我们有如下的这些问题：

1、我们需要创建一个订单

2、我们需要保存订单，但是除非我们获得了订单号，否则我们无法进行保存操作

3、我们需要打印订单，但也仅在其被保存到数据库时打印一次

看起来，这些都是非常简单的任务，甚至根本不需要使用到线程。但是为了演示这个例子，让我们假设其中的每一步都是一个很费时的操作，包含了对一个虚拟数据库的许多调用。

从上面我们的问题列表中我们可以看到，除非步骤一完成了，否则我们无法完成步骤二，除非步骤二完成了我们无法完成步骤三。这就像一个相互依赖，进退两难的困境。我们当然可以，把这几个操作放在同一个代码段中，但这违背了并发的思想，我们需要尽量保持我们应用程序的高可相应性。（记住，这里面的每一个步骤都是非常的耗时）。

所以，我们能做些什么呢？我们知道，应该把这三个步骤分配给不同的线程，但似乎有不少的问题，因为我们无法保证哪个线程将率先完成，就像我们在Parttwo中看到的那样。幸运的是，我们能够得到一些帮助。。。。

在.net中有一个WaitHandle，它允许线程等待一个特殊的WaitHandle，仅在当WaitHandle告诉正在等待的线程，它已经可以继续进行的时候才会继续进行。这种方案被称之为信号与等待。当一个线程正在等待一个WaitHandle的时候，它将被阻塞直到在某个时候WaitHandle获得信号，它允许等待线程解除阻塞，继续执行它的工作。

我喜欢将包含在WaitHandle背后的思想想象成在一个交通拥挤地带的一系列的交通灯。当栅栏(WaitHandle)没有获得信号的时候，我们(处于等待的线程)必须等待栅栏升起(获得信号)。

这就是我类比它的一种方式，而.net又是如何提供这种WaitHandles的方式给我们使用的呢？

接下来的类，是为我们使用它提供的：

l System.Threading.WaitHandle

Ø System.Threading.EventWaitHandle

Ø System.Threading.Mutex

Ø System.Threading.Semaphore

就像我们在这个层次结构中看到的一样，System.Threading.WaitHandle是一些其他System.Threading.WaitHandle派生类的基类。这里有一些特别的东西需要在我们涉及到这些派生类之前被预先解释。

一些重要的公共方法(并非所有的)如下：

SignalAndWait

该方法有几个重载，但基本的思想是——一个System.Threading.WaitHandle获得信号，而另一个System.Threading.WaitHandle将被置为等待状态直到接受一个信号。

WaitAll(WaitHandle类的静态方法)

该方法同样有几个重载，但基本的思想是——一组System.Threading.WaitHandle被压入WaitAll方法，所有的这些System.Threading.WaitHandles将被置为等到状态直到接受到一个信号。

WaitAny(WaitHandle类的静态方法)

该方法同样有几个重载，但基本的思想是——一组System.Threading.WaitHandle被压入WaitAny方法，并且任何System.Threading.WaitHandle将被置于等待直到接受到一个信号。

WaitOne

该方法同样有几个重载，但基本的思想是——当前的System.Threading.WaitHandle将被置于等待，直到接受到一个信号。

让我们集中来讲解一下System.Threading.EventWaitHandle

EventWaitHandle

EventWaitHandle是一个WaitHandle并且又有两个特别的派生类：ManualResetEvent以及AutoResetEvent，它们更加通用。这两个子类我将花些时间来讨论。所有你需要注意的是——一个EventWaitHandle对象能够充当它的两个子类的其中任何一个，通过使用EventResetMode的其中一个枚举值。在创建一个新的EventWaitHandle对象的时候，可能用得上。

现在，我们更深入地讲解一下ManualResetEvent和AutoResetEvent对象，因为他们更通用。

AutoResetEvent

来自MSDN：

“通过在AutoReseEventt上调用WaitOne，让一个线程等待一个信号。如果AutoResetEvent处于未获得信号的状态，那么线程将被阻塞，当前线程的的等待是通过调用Set方法来设置控制的资源已经可用

调用Set信号AutoReseEventt来释放一个正处于等待的线程。AutoResetEvent会保持着一个信号的状态直到一个等待线程被释放，然后自动地返回到一个非信号状态。如果没有线程当前正在等待，信号状态将会被无限期地保持。”

在外行人的术语中，当使用一个AutoResetEvent，当AutoResetEvent被设置为信号状态，第一个停止阻塞(停止等待)的线程将导致AutoResetEvent被置为一个复位状态，因此任何其他正在在AutoResetEvent上等待的线程必须等待它再次被置为信号状态。

让我们看一个小例子。启动两个线程，第一个线程将运行一段时间，然后将一个AutoResetEvent从非信号状态设置为信号状态(通过调用Set方法)。然后第二个线程将等待AutoResetEvent被再次置为信号状态。第二个线程也将等待另一个AutoResetEvent。唯一的不同是，第二个AutoResetEvent以一个信号状态为默认启动状态，所以它将无需等待。

这里是关于这个例子的代码：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
public static Thread T1;
public static Thread T2;
//this AutoResetEvent starts out non-signalled
public static AutoResetEvent ar1 = new AutoResetEvent(false);
//this AutoResetEvent starts out signalled
public static AutoResetEvent ar2 = new AutoResetEvent(true);
static void Main(string[] args)
{
#region AutoResetEvent
T1 = new Thread((ThreadStart)delegate
{
Console.WriteLine("T1 is simulating some work by sleeping for 5s");
Thread.Sleep(5000);
Console.WriteLine("T1 is just about to set AutoResetEvent ar1");
//alert waiting thread(s)
ar1.Set();
});
T2 = new Thread((ThreadStart)delegate
{
Console.WriteLine("T2 starting to wait for AutoResetEvent ar1, at time {0}", DateTime.Now.ToLongTimeString());
ar1.WaitOne();
Console.WriteLine("T2 finished waiting for AutoResetEvent ar1, at time {0}", DateTime.Now.ToLongTimeString());
Console.WriteLine("T2 starting to wait for AutoReset Event ar2, at time {0}", DateTime.Now.ToLongTimeString());
ar2.WaitOne();
Console.WriteLine("T2 finished waiting for AutoResetEvent ar2, at time {0}", DateTime.Now.ToLongTimeString());
});
T1.Name = "T1";
T2.Name = "T2";
T1.Start();
T2.Start();
Console.ReadLine();
}
#endregion
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        public static Thread T1;
        public static Thread T2;
        //this AutoResetEvent starts out non-signalled
        public static AutoResetEvent ar1 = new AutoResetEvent(false);
        //this AutoResetEvent starts out signalled
        public static AutoResetEvent ar2 = new AutoResetEvent(true);

        static void Main(string[] args)
        {
            #region AutoResetEvent
            T1 = new Thread((ThreadStart)delegate
            {
                Console.WriteLine("T1 is simulating some work by sleeping for 5s");
                Thread.Sleep(5000);
                Console.WriteLine("T1 is just about to set AutoResetEvent ar1");
                //alert waiting thread(s)
                ar1.Set();
            });

            T2 = new Thread((ThreadStart)delegate
            {

                Console.WriteLine("T2 starting to wait for AutoResetEvent ar1, at time {0}", DateTime.Now.ToLongTimeString());
                ar1.WaitOne();
                Console.WriteLine("T2 finished waiting for AutoResetEvent ar1, at time {0}", DateTime.Now.ToLongTimeString());

                Console.WriteLine("T2 starting to wait for AutoReset Event ar2, at time {0}", DateTime.Now.ToLongTimeString());
                ar2.WaitOne();
                Console.WriteLine("T2 finished waiting for AutoResetEvent ar2, at time {0}", DateTime.Now.ToLongTimeString());
            });

            T1.Name = "T1";
            T2.Name = "T2";
            T1.Start();
            T2.Start();
            Console.ReadLine();
        }
            #endregion
    }
}

它将产生下面的输出，从这里可以看出T1等待5秒（模拟操作），然后T2等待名为ar1的AutoResetEvent被置为信号状态，但不需要等待名为ar2的AutoResetEvent，因为在它被构造的时候，它已经是信号状态了。

ManualResetEvent

来自MSDN：

“当一个线程在其他线程继续之前开启一个必须完成的活动（相当于该活动具有原子性），它就可以调用Reset将ManualResetEvent置为非信号状态。该线程可以被认为是控制ManualResetEvent的线程。在ManualResetEvent上调用WaitOne的线程将被阻塞，等待信号。当控制线程完成活动，它调用Set向等待线程发出信号，让它们可以继续进行。所有的等待线程会被释放。

一旦它变成信号状态，ManualResetEvent会保持信号状态直到它被人为地重置。那便是调用WaitOne，即可直接返回”

不用术语来解释就是，在使用ManualResetEvent的时候，当ManualResetEvent被置为信号状态，所有的正处于阻塞(等待)的线程都将被允许继续进行，直到ManualReset被重置。

看下面的代码片段：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
public static Thread T1;
public static Thread T2;
public static Thread T3;
public static ManualResetEvent mr1 = new ManualResetEvent(false);
static void Main(string[] args)
{
T1=new Thread((ThreadStart)delegate{
Console.WriteLine("T1 is simulating some work by sleep for 5 secs");
Thread.Sleep(500);
Console.WriteLine("T1 is just about to set ManualResetEvent ar1");
mr1.Set();
});
T2 = new Thread((ThreadStart)delegate
{
Console.WriteLine("T2 starting to wait for ManualResetEvent mr1, at time {0}", DateTime.Now.ToLongTimeString());
mr1.WaitOne();
Console.WriteLine("T2 finished waiting for ManualResetEvent mr1 , at time (0)",DateTime.Now.ToLongTimeString());
});
T3 = new Thread((ThreadStart)delegate
{
Console.WriteLine("T3 starting to wait for ManualResetEvent mr1, at time {0}",DateTime.Now.ToLongTimeString());
mr1.WaitOne();
Console.WriteLine("T3 finished waiting for ManualResetEvent mr1 , at time (0)", DateTime.Now.ToLongTimeString());
});
T1.Name = "T1";
T2.Name = "T2";
T3.Name = "T3";
T1.Start();
T2.Start();
T3.Start();
Console.Read();
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        public static Thread T1;
        public static Thread T2;
        public static Thread T3;

        public static ManualResetEvent mr1 = new ManualResetEvent(false);

        static void Main(string[] args)
        {
            T1=new Thread((ThreadStart)delegate{
                Console.WriteLine("T1 is simulating some work by sleep for 5 secs");
                Thread.Sleep(500);
                Console.WriteLine("T1 is just about to set ManualResetEvent ar1");
                mr1.Set();
            });

            T2 = new Thread((ThreadStart)delegate
            {
                Console.WriteLine("T2 starting to wait for ManualResetEvent mr1, at time {0}", DateTime.Now.ToLongTimeString());
                mr1.WaitOne();
                Console.WriteLine("T2 finished waiting for ManualResetEvent mr1 , at time (0)",DateTime.Now.ToLongTimeString());
            });

            T3 = new Thread((ThreadStart)delegate
            {
                Console.WriteLine("T3 starting to wait for ManualResetEvent mr1, at time {0}",DateTime.Now.ToLongTimeString());
                mr1.WaitOne();
                Console.WriteLine("T3 finished waiting for ManualResetEvent mr1 , at time (0)", DateTime.Now.ToLongTimeString());

            });

            T1.Name = "T1";
            T2.Name = "T2";
            T3.Name = "T3";

            T1.Start();
            T2.Start();
            T3.Start();

            Console.Read();
        }
    }
}

它将有可能产生下面截图中的输出:

可以看到这里启动了三个线程(T1-T3)，T2与T3都在等待名为“mr1”的ManualResetEvent，它在线程T1的阻塞代码块中被标识为信号状态。当T1将mr1置为信号状态(通过调用Set()方法)时，就允许等待中的线程继续运行。当T2与T3在mr1上都被阻塞而处于等待的时候，它被置为信号状态，这样T2与T3都得以继续向下执行。而名为“mr1”的ManualResetEvent将从不会被重置(即被置为非信号状态)，所以无论是线程T2还是T3都可以自由地继续运行它们的代码块。

返回到原来的问题

再次返回到开始的问题：

1、我们需要创建一个订单

2、我们需要保存该订单，但除非我们得到该订单的编号，否则我们不能进行保存操作。

3、我们需要打印该订单，但它仅在被保存到数据库中的时候才会被打印一次。

现在该问题可以被很容易地解决了。一切我们需要的只是一些WaitHandles，我们需要它来控制那些执行的命令，在步骤二中需要等待步骤一中的WaitHandle信号，同时步骤三也需要等待步骤二的一个WaitHandle信号。简单吗？我们来看某些示例代码如何？下面是的。我简单得选择AutoResetEvent：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
public static Thread CreateOrderThread;
public static Thread SaveOrderThread;
public static Thread PrintOrderThread;
public static AutoResetEvent ar1 = new AutoResetEvent(false);
public static AutoResetEvent ar2 = new AutoResetEvent(false);
static void Main(string[] args)
{
CreateOrderThread=new Thread((ThreadStart)delegate{
Console.WriteLine("CreateOrderThread is creating the order.");
Thread.Sleep(5000);
ar1.Set();
});
SaveOrderThread = new Thread((ThreadStart)delegate
{
ar1.WaitOne();
Console.WriteLine("SaveOderThread is saving the order");
Thread.Sleep(5000);
ar2.Set();
});
PrintOrderThread = new Thread((ThreadStart)delegate
{
ar2.WaitOne();
Console.WriteLine("PrintOrderThread is printing the order");
Thread.Sleep(5000);
});
CreateOrderThread.Name = "CreateOrderThread";
SaveOrderThread.Name = "SaveOrderThread";
PrintOrderThread.Name = "PrintOrderThread";
CreateOrderThread.Start();
SaveOrderThread.Start();
PrintOrderThread.Start();
Console.Read();
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        public static Thread CreateOrderThread;
        public static Thread SaveOrderThread;
        public static Thread PrintOrderThread;

        public static AutoResetEvent ar1 = new AutoResetEvent(false);
        public static AutoResetEvent ar2 = new AutoResetEvent(false);

        static void Main(string[] args)
        {
            CreateOrderThread=new Thread((ThreadStart)delegate{
                Console.WriteLine("CreateOrderThread is creating the order.");
                Thread.Sleep(5000);
                ar1.Set();
            });

            SaveOrderThread = new Thread((ThreadStart)delegate
            {
                ar1.WaitOne();
                Console.WriteLine("SaveOderThread is saving the order");
                Thread.Sleep(5000);
                ar2.Set();
            });

            PrintOrderThread = new Thread((ThreadStart)delegate
            {
                ar2.WaitOne();
                Console.WriteLine("PrintOrderThread is printing the order");
                Thread.Sleep(5000);
            });

            CreateOrderThread.Name = "CreateOrderThread";
            SaveOrderThread.Name = "SaveOrderThread";
            PrintOrderThread.Name = "PrintOrderThread";

            CreateOrderThread.Start();
            SaveOrderThread.Start();
            PrintOrderThread.Start();

            Console.Read();
        }
    }
}

运行的结果如下图所示：

Semaphores

Semaphore继承自System,Threading.WaitHandle;因此，它有一个WaitOne()方法。你也可以使用静态的System.Threading.WaitHandle,WaitAny(),WaitAll(),SignalAndWait()方法来进行更为复杂的任务。

我读过一些文章中将Semaphore比作一个夜总会。它有一个相当大的地方能容纳很多人，当满了的时候，就不允许更多的人进入，除非有某个人离开了俱乐部，在这个时候更多的人才能够进入。

让我们来看一个简单的例子，这里Semaphore被建立来处理两个并发的请求，并且有一个总的容量为5.

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static Semaphore sem = new Semaphore(2, 5);
static void Main(string[] args)
{
for (int i = 0; i < 10; i++)
{
new Thread(RunThread).Start("T" + i);
}
Console.Read();
}
static void RunThread(object threadID)
{
while (true)
{
Console.WriteLine(string.Format("thread {0} is waiting on Semaphore",threadID));
sem.WaitOne();
try
{
Console.WriteLine(string.Format("thread {0} is in the Semaphore , and is now sleeping", threadID));
Thread.Sleep(100);
Console.WriteLine(string.Format("thread {0} is releasing Semaphore", threadID));
}
finally
{
sem.Release();
}
}
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static Semaphore sem = new Semaphore(2, 5);

        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                new Thread(RunThread).Start("T" + i);
            }

            Console.Read();
        }

        static void RunThread(object threadID)
        {
            while (true)
            {
                Console.WriteLine(string.Format("thread {0} is waiting on Semaphore",threadID));
                sem.WaitOne();

                try
                {
                    Console.WriteLine(string.Format("thread {0} is in the Semaphore , and is now sleeping", threadID));
                    Thread.Sleep(100);
                    Console.WriteLine(string.Format("thread {0} is releasing Semaphore", threadID));
                }
                finally
                {
                    sem.Release();
                }
            }
        }
    }
}

它将产生下面截图所示的输出：

该实例展示了一个怎样限制并发线程数的示例，它并非一个非常有用的示例。我将提供一个完整的代码，用它来展示如何使用一个Semaphore来限制尝试访问数据库的线程数（通过限制可访问的连接数）。数据库仅提供最多三个并发连接。就像我说的，这段代码是不完整的，并且它当前不是可以执行的状态。它仅仅是作为一个示例的目的来展示的，它也不是下载代码的一部分。

[csharp] view plain copy print ?

using System;
using System.Threading;
using System.Data;
using System.Data.SqlClient;
namespace SemaphoreTest
{
///
/// This example shows partially completed skeleton
/// code for consuming a limited resource, such as a
/// DB connection using a Semaphore
///
/// NOTE : THIS CODE WILL NOT RUN, ITS INCOMPLETE
/// DEMO ONLY CODE
///
class RestrictedDBConnectionStringAccessUsingSemaphores
{
//initial count to be satified concurrently = 1
//maximum capacity = 3
static Semaphore sem = new Semaphore(1, 3);
static void Main(string[] args)
{
//start 5 new threads that all require a Database connection
//but as a DB connection is limited to 3, we use a Semaphore
//to ensure that the number of active connections will never
//exceed the total allowable DB connections
new Thread(RunCustomersThread).Start("ReadCustomersFromDB");
new Thread(RunOrdersThread).Start("ReadOrdersFromDB");
new Thread(RunProductsThread).Start("ReadProductsFromDB");
new Thread(RunSuppliersThread).Start("ReadSuppliersFromDB");
Console.ReadLine();
}
static void RunCustomersThread(object threadID)
{
//wait for the Semaphore
sem.WaitOne();
//the MAX DB connections must be within its limited
//so proceed to use the DB
using (new SqlConnection(""))
{
//do our business with the database
}
//Done with DB, so release Semaphore which will
//allow another into the Semaphore
sem.Release();
}
static void RunOrdersThread(object threadID)
{
//wait for the Semaphore
sem.WaitOne();
//the MAX DB connections must be within its limited
//so proceed to use the DB
using (new SqlConnection(""))
{
//do our business with the database
}
//Done with DB, so release Semaphore which will
//allow another into the Semaphore
sem.Release();
}
static void RunProductsThread(object threadID)
{
//wait for the Semaphore
sem.WaitOne();
//the MAX DB connections must be within its limited
//so proceed to use the DB
using (new SqlConnection(""))
{
//do our business with the database
}
//Done with DB, so release Semaphore which will
//allow another into the Semaphore
sem.Release();
}
static void RunSuppliersThread(object threadID)
{
//wait for the Semaphore
sem.WaitOne();
//the MAX DB connections must be within its limited
//so proceed to use the DB
using (new SqlConnection(""))
{
//do our business with the database
}
//Done with DB, so release Semaphore which will
//allow another into the Semaphore
sem.Release();
}
}
}

using System;
using System.Threading;
using System.Data;
using System.Data.SqlClient;

namespace SemaphoreTest
{
    /// 
    /// This example shows partially completed skeleton
    /// code for consuming a limited resource, such as a
    /// DB connection using a Semaphore
    /// 
    /// NOTE : THIS CODE WILL NOT RUN, ITS INCOMPLETE
    ///        DEMO ONLY CODE
    /// 
    class RestrictedDBConnectionStringAccessUsingSemaphores
    {

        //initial count to be satified concurrently = 1
        //maximum capacity = 3
        static Semaphore sem = new Semaphore(1, 3);

        static void Main(string[] args)
        {
            //start 5 new threads that all require a Database connection
            //but as a DB connection is limited to 3, we use a Semaphore
            //to ensure that the number of active connections will never
            //exceed the total allowable DB connections
            new Thread(RunCustomersThread).Start("ReadCustomersFromDB");
            new Thread(RunOrdersThread).Start("ReadOrdersFromDB");
            new Thread(RunProductsThread).Start("ReadProductsFromDB");
            new Thread(RunSuppliersThread).Start("ReadSuppliersFromDB");
            Console.ReadLine();
        }

        static void RunCustomersThread(object threadID)
        {
            //wait for the Semaphore
            sem.WaitOne();
            //the MAX DB connections must be within its limited
            //so proceed to use the DB
            using (new SqlConnection(""))
            {
                //do our business with the database
            }
            //Done with DB, so release Semaphore which will
            //allow another into the Semaphore
            sem.Release();
        }

        static void RunOrdersThread(object threadID)
        {
            //wait for the Semaphore
            sem.WaitOne();
            //the MAX DB connections must be within its limited
            //so proceed to use the DB
            using (new SqlConnection(""))
            {
                //do our business with the database
            }
            //Done with DB, so release Semaphore which will
            //allow another into the Semaphore
            sem.Release();
        }

        static void RunProductsThread(object threadID)
        {
            //wait for the Semaphore
            sem.WaitOne();
            //the MAX DB connections must be within its limited
            //so proceed to use the DB
            using (new SqlConnection(""))
            {
                //do our business with the database
            }
            //Done with DB, so release Semaphore which will
            //allow another into the Semaphore
            sem.Release();
        }

        static void RunSuppliersThread(object threadID)
        {
            //wait for the Semaphore
            sem.WaitOne();
            //the MAX DB connections must be within its limited
            //so proceed to use the DB
            using (new SqlConnection(""))
            {
                //do our business with the database
            }
            //Done with DB, so release Semaphore which will
            //allow another into the Semaphore
            sem.Release();
        }
    }
}

从这个简单的例子中可以很清楚地看到，Semaphore仅允许最多三个线程（这是在Semaphore中的构造器中设置的），所以我们可以确信的是，数据库的连接也将会被限制。

Mutex

Mutex很大程度上像以lock状态(我们将在接下来的后面的章节进行讲解)的方式工作着，所以暂时我不想涉及太多。但Mutex比起lock以及Monitor最主要的优势是它能够跨多进程运行，它提供一种计算机级别的lock而不是应用程序级别。

应用程序的单个实例

Mutex最通用的一个用途就是确保一个应用程序在运行的时候仅有一个实例。

让我们看看一些代码。该代码可以确保一个应用程序的单个实例。任何一个新的实例将等待5秒钟（除非当前正在运行的实例处于关闭中），假设在这之前已经有一个正在运行的应用程序。

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static Mutex mutex = new Mutex(false, "MutexText");
static void Main(string[] args)
{
if (!mutex.WaitOne(TimeSpan.FromSeconds(5)))
{
Console.WriteLine("MutexText already running! Exiting");
return;
}
try
{
Console.WriteLine("MutexTest started");
Console.ReadLine();
}
finally
{
mutex.ReleaseMutex();
}
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static Mutex mutex = new Mutex(false, "MutexText");

        static void Main(string[] args)
        {
            if (!mutex.WaitOne(TimeSpan.FromSeconds(5)))
            {
                Console.WriteLine("MutexText already running! Exiting");
                return;
            }
            try
            {
                Console.WriteLine("MutexTest started");
                Console.ReadLine();
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }
    }
}

所以，如果我们启动一个应用程序的实例，我们能够看到如下的截图：

当我们尝试运行另一份拷贝的话，我们将得到下面的结果（在五分钟的延迟之后）：

临界区域

锁是一种能够确保某一时刻仅有一个线程能够访问一个特殊的代码区域的解决方案。这就是锁的作用。总是被锁住的代码段被称之为“临界区域”。有很多不同的方式可以锁住一段临界区域，下面将有所说明。

但在这之前，让我们来看看为什么我们需要这些所谓的“临界区域”中的代码。考虑一下下面的代码：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static int item1 = 54, item2 = 21;
public static Thread T1;
public static Thread T2;
static void Main(string[] args)
{
T1 = new Thread((ThreadStart)delegate
{
DoCalc();
});
T2 = new Thread((ThreadStart)delegate
{
DoCalc();
});
T1.Name = "T1";
T2.Name = "T2";
T1.Start();
T2.Start();
}
private static void DoCalc()
{
item2 = 10;
if (item1!=0)
{
Console.WriteLine(item1 / item2);
}
item2 = 0;
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static int item1 = 54, item2 = 21;
        public static Thread T1;
        public static Thread T2;

        static void Main(string[] args)
        {
            T1 = new Thread((ThreadStart)delegate
            {
                DoCalc();
            });

            T2 = new Thread((ThreadStart)delegate
            {
                DoCalc();
            });
            T1.Name = "T1";
            T2.Name = "T2";

            T1.Start();
            T2.Start();
        }

        private static void DoCalc()
        {
            item2 = 10;
            if (item1!=0)
            {
                Console.WriteLine(item1 / item2);
            }
            item2 = 0;
        }
    }
}

这段代码并非是线程安全的，因为它能够被两个不同的模拟线程访问。一个线程能将item2设置为0，此刻当另一个线程正尝试做除法的时候，将导致一个DivideByZeroException异常。

现在，当你运行这段代码，这个问题可能会每500ms出现一次，但这是一种很自然的线程问题。它们仅重现很短的时间，所以很难找到原因。你真的需要想到方方面面的情况，在你写代码之前，并且确保你在正确的地方进行安全防卫。

很幸运的是，我们可以使用锁机制来解决该问题。下面是一个简易的Demo：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static object syncLock = new object();
static int item1 = 54, item2 = 21;
public static Thread T1;
public static Thread T2;
static void Main(string[] args)
{
T1 = new Thread((ThreadStart)delegate
{
DoCalc();
});
T2 = new Thread((ThreadStart)delegate
{
DoCalc();
});
T1.Name = "T1";
T2.Name = "T2";
T1.Start();
T2.Start();
Console.ReadLine();
}
private static void DoCalc()
{
lock (syncLock)
{
item2 = 10;
if (item1 != 0)
{
Console.WriteLine(item1 / item2);
}
item2 = 0;
}
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static object syncLock = new object();
        static int item1 = 54, item2 = 21;
        public static Thread T1;
        public static Thread T2;

        static void Main(string[] args)
        {
            T1 = new Thread((ThreadStart)delegate
            {
                DoCalc();
            });

            T2 = new Thread((ThreadStart)delegate
            {
                DoCalc();
            });
            T1.Name = "T1";
            T2.Name = "T2";

            T1.Start();
            T2.Start();

            Console.ReadLine();
        }

        private static void DoCalc()
        {
            lock (syncLock)
            {
                item2 = 10;
                if (item1 != 0)
                {
                    Console.WriteLine(item1 / item2);
                }
                item2 = 0;
            }
            
        }
    }
}

在这个例子中，我们引进了第一种可行的技术来创建一个临界区，通过使用lock关键字。一次仅一个线程能够锁住同步对象（syncLock,在这个示例中）。任何其他的竞争线程都会被阻塞直到锁被释放。任何其他的竞争线程都被加入到一个“就绪队列中”，其给予访问的机制基于FCFS（First come first serviced,先来先服务）。

某些人对同步对象使用lock(this)或者lock(typeof(MyClass))。这是一个糟糕的想法，因为它们都是公有成员对象，所以，一个外部实体可以用它们来同步以及作为你线程的一个“接口”，从而导致一些很奇怪的问题。所以，最好的实践是使用一个私有的同步对象。

现在，我们来很认真地讨论一下你可以使用锁的几种不同的方式。

Lock关键字

我们已经看了一个简单的例子，在例子中我们使用了lock关键字，我们可以使用lock来“锁住”一个特殊对象。这是一种很通用的方案。

值得一提的是，lock关键字确实只是一种使用Monitor类的“快捷方式”。

Monitor类

System.Threading命名空间包含有一个叫做Monitor的类，它能够完全做到lock关键字一样的事情。如果我们考虑我们上面使用lock关键字锁住的相同的代码段，你可以看到Monitor能够做到同样的工作。

[csharp] view plain copy print ?

using System;
using System.Threading;
namespace LockTest
{
///
/// This shows how to create a critical section
/// using the Monitor class
///
class Program
{
static object syncLock = new object();
static int item1 = 54, item2 = 21;
static void Main(string[] args)
{
Monitor.Enter(syncLock);
try
{
if (item1 != 0)
Console.WriteLine(item1 / item2);
item2 = 0;
}
finally
{
Monitor.Exit(syncLock);
}
Console.ReadLine();
}
}
}

using System;
using System.Threading;

namespace LockTest
{
    /// 
    /// This shows how to create a critical section
    /// using the Monitor class
    /// 
    class Program
    {
        static object syncLock = new object();
        static int item1 = 54, item2 = 21;


        static void Main(string[] args)
        {
            Monitor.Enter(syncLock);
            try
            {
                if (item1 != 0)
                    Console.WriteLine(item1 / item2);
                item2 = 0;
            }
            finally
            {
                Monitor.Exit(syncLock);
            }
            Console.ReadLine();
        }
    }
}

这里，lock关键字仅仅是下面这段Monitor代码的“语法糖”

[csharp] view plain copy print ?

Monitor.Enter(syncLock);
try
{
}
finally
{
Monitor.Exit(syncLock);
}

Monitor.Enter(syncLock);
try
{

}
finally
{
    Monitor.Exit(syncLock);
}

Lock关键字确实等效于这段代码。

MethodImpl.Synchronized特性

最后一种方式是依赖一个特性的使用，该特性能够告诉编译器将其当做一个同步方法。

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MethodImplSynchronizedTest
{
///
/// This shows how to create a critical section
/// using the System.Runtime.CompilerServices.MethodImplAttribute
///
class Program
{
static int item1=54, item2=21;
static void Main(string[] args)
{
//make a call to different method
//as cant Synchronize Main method
DoWork();
}
[System.Runtime.CompilerServices.MethodImpl
(System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]
private static void DoWork()
{
if (item1 != 0)
Console.WriteLine(item1 / item2);
item2 = 0;
Console.ReadLine();
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MethodImplSynchronizedTest
{
    /// 
    /// This shows how to create a critical section
    /// using the System.Runtime.CompilerServices.MethodImplAttribute
    /// 
    class Program
    {
        static int item1=54, item2=21;

        static void Main(string[] args)
        {
            //make a call to different method
            //as cant Synchronize Main method
            DoWork();
        }

        [System.Runtime.CompilerServices.MethodImpl
        (System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]
        private static void DoWork()
        {
            if (item1 != 0)
                Console.WriteLine(item1 / item2);
            item2 = 0;
            Console.ReadLine();
        }
    }
}

这个简单的例子展示了你可以使用System.Runtime.CompilerService.MethodImplAttribute来将一个方法标识为同步（临界区域）。

有件事情需要注意的是，如果你锁住整个方法，你可能会失去更多的并发编程的机会，因为它比起单线程模型运行方法的方式没有太多的性能优势。出于这个原因，你应该尽可能尝试将临界区域“圈定”为那些在多线程访问时需要实现线程安全的字段上。所以在你读写公共字段的时候，尝试使用锁机制。

当然，还是存在某些场景，你可能需要将整个方法标注为临界区域，但这是你的决定。只是，你需要意识到，锁住的区域应该越小越好。

Miscellaneous Objects

这里有两个外部的类，我觉得值得一提：

Interlocked

“一个声明操作是原子的，如果把它作为一个单一不可分割的指令的话。严格的原子性将排除任何抢占的可能性。在C#中，对一个32位或者更少的bits的字段简单的读取或者分配是原子的(假设在一个32位CPU上)。而对一个更大的字段的操作则是非原子的，因为它们可能包含了不止一个读/写操作。”

考虑下面的代码：

[csharp] view plain copy print ?

using System;
using System.Threading;
namespace AtomicTest
{
class AtomicTest
{
static int x, y;
static long z;
static coid Test()
{
long myVar;
x = 3; //Atomic
z = 3; //Non atomic as Z is 64 bits
myVar = z; //Non atomic as Z is 64 bits
y += x; //Non atomic read and write
x++; //Non atomic read and write
}
}
}

using System;
using System.Threading;

namespace AtomicTest
{
    class AtomicTest
    {
        static int x, y;
        static long z;

        static coid Test()
        {
            long myVar;

            x = 3;          //Atomic
            z = 3;          //Non atomic as Z is 64 bits
            myVar = z;      //Non atomic as Z is 64 bits
            y += x;         //Non atomic read and write
            x++;            //Non atomic read and write
        }
    }
}

解决这种问题的方法可以是，将非原子性的操作包裹到一个lock定义中。然而，有一个.net的类提供一个更简单也更快速的方案。那就是Interlocked类。使用Interlocked类比使用lock声明更安全，因为Interlocked永远都不会阻塞。

MSDN声明：

“当调度器在一个线程正在更新一个可被另一个线程访问的变量时切换上下文，或者当两个线程在隔离的处理器上并发执行时，该类的方法能够防止错误的发生。该类的成员不会抛出任何异常。”

这里有一个使用Interlocked演示的小例子：

[csharp] view plain copy print ?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static long currentValue;
static void Main(string[] args)
{
Interlocked.Increment(ref currentValue);
Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));
Interlocked.Decrement(ref currentValue);
Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));
Interlocked.Add(ref currentValue, 5);
Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));
//read a 64 bit value
Console.WriteLine(String.Format("The value of currentValue is {0}",Interlocked.Read(ref currentValue)));
Console.ReadLine();
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static long currentValue;

        static void Main(string[] args)
        {
            Interlocked.Increment(ref currentValue);
            Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));

            Interlocked.Decrement(ref currentValue);
            Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));

            Interlocked.Add(ref currentValue, 5);
            Console.WriteLine(string.Format("The value of currentValue is {0}", Interlocked.Read(ref currentValue)));

            //read a 64 bit value
            Console.WriteLine(String.Format("The value of currentValue is {0}",Interlocked.Read(ref currentValue)));

            Console.ReadLine();
        }


    }
}

这将会产生如下的输出：

Interlocked类也提供各种其他的方法，例如：

l CompareExchange(location1,value,comparand):如果comparand与location1里的值相等，value将会被存入location1。否则，没有操作执行。比较和交换操作被作为一个原子操作执行。CompareExchange的返回值是location1里面的值，无论是否有任何的交换发生。

l Exchange(location1,value)：作为一个原子操作，将一个特殊值设置到某个位置，并返回原始的值。

这两个Interlocked中的方法能够实现无锁(无等待)的算法以及数据结构，否则你就得实现完整的锁机制来处理。

Volatile

Volatile关键字可以用来共享一个字段。Volatile关键字指示一个字段在程序中可以被操作系统、硬件或者一个并发执行的线程修改。

MSDN的说法：

“系统总是在它需要的时候读取一个volatile对象的当前值，甚至在之前的指令刚刚请求了相同的对象。给对象分配的值也会被实时地写入。

Volatile修改器通常用来对一个可以被多线程访问而没有使用lock生命的字段的顺序访问。使用volatile修改器能够确保一个线程检索到被另一个线程最近更新的值。”

ReaderWriterLockSlim

经常存在这样一种情况——一个类型的实例对于读操作是类型安全的，但对于更新操作却不是。尽管这个问题可以使用lock声明来解决，但当有很多读取操作而没有太多写操作的情况下，这种解决方案可能相当有限制性。而ReaderWriterLockSlim类就是被设计用来处理该问题的。

ReaderWriterLockSlim类（该类为.net3.5新增）提供了两种锁的方式：一个读锁和一个写锁。写锁是独占的，而一个读锁是兼容其他读锁的。

说白点，一个线程占用一个写锁，它将阻塞所有其他线程设置尝试读或写锁。如果当前没有一个线程把持一个写锁，那么任何数量的线程都可以把持一个读锁。

该类主要的方法给使用这些锁提供了方便，这些方法如下：

1、 EnterReadLock(*)

2、 ExitReadLock

3、 EnterWriteLock(*)

4、 ExitWriteLock(*)

这里*表示也存在一个更安全点的“尝试版本”可以使用，它支持设置一个超时时间。

让我们来看一个简单的例子：

[csharp] view plain copy print ?

using System;
using System;
using System.Threading;
using System.Collections.Generic;
namespace ReaderWriterLockSlimTest
{
///
/// This simple class demonstrates the usage a Reader/Writer
/// situation, using the ReaderWriterLockSlim class
///
class Program
{
static ReaderWriterLockSlim rw = new ReaderWriterLockSlim();
static List<int> items = new List<int>();
static Random rand = new Random();
static void Main(string[] args)
{
//start some readers
new Thread(Read).Start("R1");
new Thread(Read).Start("R2");
new Thread(Read).Start("R3");
//start some writers
new Thread(Write).Start("W1");
new Thread(Write).Start("W2");
}
static void Read(object threadID)
{
//do read
while (true)
{
try
{
rw.EnterReadLock();
Console.WriteLine("Thread " + threadID +
" reading common source");
foreach (int i in items)
Thread.Sleep(10);
}
finally
{
rw.ExitReadLock();
}
}
}
static void Write(object threadID)
{
//do write
while (true)
{
int newNumber = GetRandom(100);
try
{
rw.EnterWriteLock();
items.Add(newNumber);
}
finally
{
rw.ExitWriteLock();
Console.WriteLine("Thread " + threadID +
" added " + newNumber);
Thread.Sleep(100);
}
}
}
static int GetRandom(int max)
{
//lock on the Random object
lock (rand)
return rand.Next(max);
}
}
}

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

namespace ReaderWriterLockSlimTest
{
    /// 
    /// This simple class demonstrates the usage a Reader/Writer 
    /// situation, using the ReaderWriterLockSlim class
    /// 
    class Program
    {
        static ReaderWriterLockSlim rw = new ReaderWriterLockSlim();
        static List items = new List();
        static Random rand = new Random();

        static void Main(string[] args)
        {
            //start some readers
            new Thread(Read).Start("R1");
            new Thread(Read).Start("R2");
            new Thread(Read).Start("R3");

            //start some writers
            new Thread(Write).Start("W1");
            new Thread(Write).Start("W2");
        }

        static void Read(object threadID)
        {
            //do read
            while (true)
            {
                try
                {
                    rw.EnterReadLock();
                    Console.WriteLine("Thread " + threadID +
                        " reading common source");
                    foreach (int i in items)
                        Thread.Sleep(10);
                }
                finally
                {
                    rw.ExitReadLock();
                }
            }
        }

        static void Write(object threadID)
        {
            //do write
            while (true)
            {
                int newNumber = GetRandom(100);
                try
                {
                    rw.EnterWriteLock();
                    items.Add(newNumber);
                }
                finally
                {
                    rw.ExitWriteLock();
                    Console.WriteLine("Thread " + threadID +
                        " added " + newNumber);
                    Thread.Sleep(100);
                }
            }
        }

        static int GetRandom(int max)
        {
            //lock on the Random object
            lock (rand)
                return rand.Next(max);
        }
    }
}

有可能会产生如下的输出：

需要注意的是，在System.Threading命名空间下，也存在一个ReaderWriterLock类。这就是为什么MSDN不得不说明ReaderWriterLockSlim(.net 3.5)与ReaderWriterLock(.net2.0)不同之处的原因：

“ReaderWriterLockSlim与ReaderWriterLock类似，但它简化了对递归与锁状态升级与降级的规则。ReaderWriterLockSlim避免了许多死锁的情况。另外其性能也明显好过ReaderWriterLock。在所有新的开发中，推荐使用ReaderWriterLockSlim类”

你可能感兴趣的:(多线程,委托)

水泥质量纠纷案代理词徐宝峰律师
贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
EIO国际确定性的交易（3/10）资管，资金委托安全吗？古城鹏哥
大家可能都知道资金托管，账户是自己开，钱在自己的账户上，密码是由自己掌控，别人提不走你账户的资金，每天可以看下到自己的账户，也可以看到交易流水。现金只能提到自己的银行卡中。账户由技术人员或操作人员，或者是机构团队帮你操作账户，产生盈利和收入，以获得的利润来分配盈利，技术强硬和做的时间久了过硬技术团队，会保证你的资金本金，不会让你的本金亏损的按照一定比例分配收入。所以在这个过程当中一定要看清楚技术的
多线程之——ExecutorCompletionService 阿福德
在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
python多线程程序设计之一 IT_Beijing_BIT #Python 程序设计语言 python
python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
Python多线程实现大规模数据集高效转移 sand&wich 网络 python 服务器
背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
Python实现下载当前年份的谷歌影像 sand&wich python 开发语言
在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
一个纯真姑娘被现实社会磨灭了热情幽律
每个初入社会的人，都是满怀憧憬，热情对待这个社会，可往往都是被回馈以欺骗，恐吓，磨灭了热情。我的一个朋友，小吴，来自安徽的姑娘，初出校门，来到这座南方经济发达的城市，善良单纯，待人对事充满了朝气与热情。当时小吴所在的房产中介公司有一位女客户，是退休教师，谈吐方面能感觉得到很有素质，和她先生想要买房，小吴接待的。了解情况后，客户感觉经济方面还是有点压力的，所以委托小吴先帮她卖自己的旧房，周转开来再买
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
[面试高频问题]关于多线程的单例模式朱玥玥要每天学习 java 单例模式开发语言
单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
奇怪的律师禹英雨之阴谋阳谋何事萦心
陈平信命，所以自我总结说一生阴谋用的太多，有碍子孙。他这个人有才，但只是耍小聪明，无法独当一面。拿来应急可，拿来破局可，但是他拥有没有张良那稳稳的阳谋。律师也是人，禹英雨受委托就要辩护。这是从古代有讼师这个行业以来，就避免不了的矛盾。完全为了法律的尊严，绝大多数人不行。要行就都是天秤了。但很多律师还是有道德底线的。这个案子就是商业竞争的一种手段。先破坏人的口碑再说。产品怕避雷，银行金融业怕挤兑。提
基于flask做大模型SSE输出 Mark_Aussie nlp flask python 后端
默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
为什么Node.js不适合CPU密集型应用？ weixin_54503231 node.js
Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
PCL 点云视窗类CloudViewer LeonDL168 PCL 算法计算机视觉人工智能视觉检测图像处理
点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
因在船上做噩梦，他坚持中途下船，结果船上211人只有他幸存！三晋风云客
大家都知道，现代社会是讲究科学和逻辑的理性社会。不过依旧有一些科学无法解释的情况存在，比如英国一位神秘的巫婆，据悉她从小便有预言能力，在长大后更是预言了美国总统的人选。但是医学和科学方面并不能解释这种奇怪的现象。今天要向大家介绍的这个神秘事件，也是一个至今未能得到科学解释的谜题，它就是瓦拉塔赫失踪之谜。正文事情发生在英国，1908年，蓝猫航运公司将造船的任务委托给巴克利与柯尔公司。经过这家造船公司
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
《Android进阶之光》— Android 书籍王睿丶 Android 永无止境《Android进阶之光》Android书籍 Android phoenix 移动开发
文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
《android进阶之光》——多线程编程（上） TAING要一直努力读书笔记
今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
Unity3D多线程UI之ScrollYExtand 胡强_79a4
先附上git地址https://github.com/huqiang0204/huqiang.UnitySubThreadUI示例代码请看ScrollExTestPage可以绑定三种模型，头部，尾部，和中间数据部分这里只用到了中间数据模型和头部模型Listdatas=newList();ScrollYExtand.DataTemplatetmp=newScrollYExtand.DataTempl
多线程相关面试题（2024大厂高频面试题系列）小橘子831 后端面试 java 面试后端
1、聊一下并行和并发有什么区别？并发是同一时间应对多件事情的能力，多个线程轮流使用一个或多个CPU并行是同一时间动手做多件事情的能力，4核CPU同时执行4个线程2、说一下线程和进程的区别？进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间3、如果在java中创建线程有哪些方式？在java中一共有四种常见的创建方式，
Java多线程相关面试题整理长河落日袁同学不积跬步无以至千里 java 笔记多线程锁面试
目录1.什么是线程和进程？线程与进程有什么区别？那什么是上下文切换？进程间怎么通信？什么是用户线程和守护线程？2.并行和并发的区别？3.创建线程的几种方式？Runnable接口和Callable接口的区别？run()方法和start()有什么区别？4.Java线程状态和方法？描述线程的生命周期？一个线程两次调用start()方法会出现什么情况？sleep()和wait()方法的区别是什么？5.并发
python 多线程抓取xunlei磁力下载链接 weixin_53748624 python pycharm
importurllib.requestimportreimporttimeimportthreadingclassSpider(object):def__init__(self):#定义字典，用于保存影片信息self.films_dict={}self.i=1self.lock1=threading.Lock()defstart(self):#调用下载函数，获取下载连接forpageinrang
思念寄于心
老娘离开我们三年半了，每年的今天，老家人都烧衣烧纸烧烧房子烧金元才宝。为了避免有误，各家都在这些上面写上名字。今天，大姐，妹妹告诉我在老屋门口己经烧好了，我委托她们挑好点的买，今晚，妈妈可以回家去收下了。希望你富足健康，快乐无烦恼。在我的心里面，妈妈你从没有离开过。你说过的做过的用过的一直没有离开过我。你说过的一直深深地驻扎在心理。你说的又很多。因此，我，只是一直在重复那些话。每逄佳节，扶起筷子，
Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发 Java高并发 Java 高并发
上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
Redis 为什么这么快？小海海不怕困难 Redis redis
决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
Python 课程8-多线程编程和多进程编程可愛小吉 Python教學 python 开发语言 threading multiprocessing
前言在现代编程中，处理并发任务是提高程序性能的关键之一。Python提供了多线程（threading）和多进程（multiprocessing）两种方式来实现并发编程。多线程适用于I/O密集型任务，而多进程则更适合CPU密集型任务。通过这两种技术，你可以高效地处理大规模数据、加速程序执行并优化资源利用。在本篇详细教程中，我们将讨论如何使用Python的threading模块实现多线程，以及如何使用
C++多线程的简单使用好学松鼠 C++C++多线程 async promise
多线程的使用，本文主要简单介绍使用多线程的几种方式，并使用几个简单的例子来介绍多线程，使用编译器为visualstudio。一、AsyncFuture使用的知识点有std::async和std::future1、std::async函数原型templatefuture::type>async(launchpolicy,Fn&&fn,Args&&...args);功能：第二个参数接收一个可调用对象（
C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
java基础-线程间通信方式问道飞鱼 Java开发技术 java 开发语言
文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
Java 中自定义线程池胡英俊俊俊 #JUC java 开发语言
Java中自定义线程池的方式在Java开发中，线程池是非常常用的工具，它能够帮助我们更好地管理多线程任务，提升并发性能并避免过度创建线程导致的系统资源消耗。在Java中，线程池主要由ThreadPoolExecutor提供，该类支持自定义线程池的核心参数，如线程数、任务队列以及拒绝策略等。在这篇文章中，我们将讨论如何通过ThreadPoolExecutor来实现自定义线程池，以及常用的配置和使用方
解线性方程组 qiuwanchi
package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
在mysql内部存储代码 annan211 性能 mysql 存储过程触发器
在mysql内部存储代码在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
Asynchronous Http Client是android中非常好的异步请求工具除了异步之外还有很多封装比如json的处理，cookie的处理引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
java面试题 Array_06 java 面试
java面试题第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
网站加速 oloz 网站加速
前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩； GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
正确书写单例模式随意而生 java 设计模式单例
　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。　　懒汉式，线程不安全　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
单例模式香水浓 java
懒汉调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apache http server
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它（譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
如何在android 文件选择器中选择多个图片或者视频？ aijuans android
我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传但是android原生态的sdk中，只能一个一个的进行选择和上传。我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个处理方法官方的图片选择器(但是不支持所有版本的androi，只支持API Level
mysql中查询生日提醒的日期相关的sql baalwolf mysql
SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(), dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。解决方案：使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
Javascript Promise bijian1013 JavaScript Promise
Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。一.认识Promises “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
[Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是 public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
【Java命令三】jstack bit1129 jstack
jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
jboss 5.1启停脚本　动静分离部署 ronin47
以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename -b ip -g clustername -u broatcast jboss.messaging.ServerPeerID=int -Djboss.service.binding.set=p
UI之如何打磨设计能力? brotherlamp UI ui教程 ui自学 ui资料 ui视频
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
三色旗算法 bylijinnan java 算法
import java.util.Arrays; /** 问题：假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。网上的解法大多类似：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
警告:No configuration found for the specified action: \'s chiangfai configuration
1.index.jsp页面form标签未指定namespace属性。  <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redis hash
使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255 /* Return th
select into outfile access deny问题 daizj mysql txt 导出数据到文件
本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。授权的语句如下： grant select on armory.* to rn
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
<?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
美国电影超短200句 dcj3sjt126com 电影
1. I see．我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too．我也是。5. My god! 天哪!6. No way! 不行!7. Come on．来吧(赶快)8. Hold on．等一等。9. I agree。我同意。10. Not bad．还不错。11. Not yet．还没。12. See you．再见。13. Shut up!
Java访问远程服务 dyy_gusi httpclient webservice get post
随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
Maven的settings.xml配置 geeksun settings.xml
settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
ubuntu的init与系统服务设置 hongtoushizi ubuntu
转载自： http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。运行
跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginx lua
使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。目录第一章安装Nginx+Lua开发环境第二章 Nginx+Lua开发入门第三章 Redis/SSDB+Twemproxy安装与使用第四章 L
php位运算符注意事项 home198979 位运算 PHP &
$a = $b = $c = 0; $a & $b = 1; $b | $c = 1 问a,b,c最终为多少? 当看到这题时，我犯了一个低级错误，误以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b; 这样a,b的值不会有任何改变
Linux shell数组建立和使用技巧 pda158 linux
1.数组定义　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。　　 2.数组读取与赋值　　得到长度：　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
hotspot源码(JDK7) ol_beta java HotSpot jvm
源码结构图，方便理解： ├─agent Serviceab
Oracle基本事务和ForAll执行批量DML练习 vipbooks oracle sql
基本事务的使用：从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam