internal void ExitCPUContext(ICPUContext CPUContext)
{
System.Diagnostics.Debug.Assert(CPUContext.IsCurrent());
((CPUContext)CPUContext).Release();
// UnlockCPUでは、deleteしたCPUContextに対してEndDelaySuspendを
// 呼んでしまうので、その手前の処理のみ実行。
int TlsLockCount = (int)m_TlsIndex.Value;
TlsLockCount--;
// ロック解除
if (TlsLockCount == 0)
{
m_SysSem.Release();
Interlocked.Decrement(ref m_Locked);
}
m_TlsIndex.Value = TlsLockCount;
m_IntEvent.Set();
CPUContext.Exit();
}
public Boolean Send(string data)
{
try
{
semaphor.WaitOne();
//Type
byte[] buffer = new byte[data.Length];
buffer = Encoding.ASCII.GetBytes(data);
if ((Clientsocket != null) && Clientsocket.Connected)
{
int BytesSent = Clientsocket.Send(buffer, data.Length, SocketFlags.None);
semaphor.Release();
return(Clientsocket.Connected && (BytesSent == data.Length));
}
else
{
semaphor.Release();
return(false);
}
}
catch
{
semaphor.Release();
return(false);
}
}
private void Method(object obj)
{
listBox2.Invoke((Action) delegate() { listBox2.Items.Remove("Поток " + (int)obj + " --> Очікує"); });
listBox1.Invoke((Action) delegate() { listBox1.Items.Add("Поток " + (int)obj + " --> 1"); });
while (true)
{
Sem.WaitOne();
if (!list.ContainsKey((int)obj))
{
list[(int)obj] = 1;
}
else
{
try
{
listBox1.Invoke((Action) delegate() { listBox1.Items.Remove("Поток " + (int)obj + $" --> {list[(int)obj]}"); });
list[(int)obj] = list[(int)obj] + 1;
listBox1.Invoke((Action) delegate() { listBox1.Items.Add("Поток " + (int)obj + $" --> {list[(int)obj]}"); });
}
catch
{
}
}
Sem.Release();
Thread.Sleep(1000);
}
}
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (this.txtLog.Text.Length / (float)this.txtLog.MaxLength > 0.95)
{
this.txtLog.Clear();
}
this.txtLog.AppendText("\r\n");
ReportStat rs = (ReportStat)e.UserState;
if (rs.step == 0) //开始处理
{
this.lblWork.Text = rs.msg;
this.lblPercent.Text = string.Format("{0}%", e.ProgressPercentage);
this.lblCount.Text = string.Format("{0}/{1}", rs.currentIndex + 1, _tcRows.Length);;
}
else if (rs.step == 1) //正常进行中----
{
this.progressBarControl1.Value = e.ProgressPercentage;
this.lblPercent.Text = string.Format("{0}%", e.ProgressPercentage);
this.txtLog.AppendText("正处理。第------" + rs.currentIndex + "条记录" + rs.msg);
}
else if (rs.step == 2)//点了暂停按钮 后
{
this.btnPause.Enabled = true;
this.btnPause.Text = "继续";
}
else if (rs.step == 3)//点了继续 按钮后
{
this.btnPause.Enabled = true;
this.btnPause.Text = "暂停";
}
else if (rs.step == 4)
{
DialogResult dr = MessageBox.Show(this, "出错，忽略？终止？重试", "错误", MessageBoxButtons.AbortRetryIgnore);
if (dr == DialogResult.Ignore)
{
//忽略继续
_bPause = 0;
_semaPause.Release();
}
else if (dr == DialogResult.Abort)
{
//设为暂停状态
this.btnPause.Enabled = true;
this.btnPause.Text = "继续";
}
else
{
//重试 i 减一 继续
Interlocked.Decrement(ref i);
_bPause = 0;
_semaPause.Release();
}
this.progressBarControl1.Value = e.ProgressPercentage;
this.lblPercent.Text = string.Format("{0}%", e.ProgressPercentage);
this.txtLog.AppendText("出错:" + rs.msg);
}
}
public static void Main()
{
const int count = 4;
_desk = new Semaphore(0, count - 1);
var forks = new List<Fork>(count);
var philosophers = new List<Philosopher>(count);
for (var i = 0; i < count; i++)
{
forks.Add(new Fork {Number = i});
}
philosophers.Add(new Philosopher(_desk, count - 1) { LeftFork = forks[count - 1], RightFork = forks[0], Number = 0, HungerLevel = 0 });
for (var i = 1; i < count; i++)
{
philosophers.Add(new Philosopher(_desk, count - 1) { LeftFork = forks[i - 1], RightFork = forks[i], Number = i, HungerLevel = count - 1 });
}
var tasks = new Task[count];
for (var i = 0; i < count; i++)
{
var idx = i;
tasks[idx] = new Task(() => philosophers[idx].Start());
}
_desk.Release(count - 1);
Parallel.ForEach(tasks, t => t.Start());
Console.ReadKey();
}
private void FriendsListForm_FormClosed(object sender, FormClosedEventArgs e)
{
if (_exitType == MainFormExitType.Exit)
{
if (_nrtcInit)
{
//退出前需要结束音视频设备，防止错误的数据上报
MultimediaHandler.EndDevices();
System.Threading.Thread.Sleep(500);
//在释放前需要按步骤清理音视频模块和nim client模块
NIM.VChatAPI.Cleanup();
}
if (!_beKicked)
{
System.Threading.Semaphore s = new System.Threading.Semaphore(0, 1);
NIM.ClientAPI.Logout(NIM.NIMLogoutType.kNIMLogoutAppExit, (r) =>
{
s.Release();
});
//需要logout执行完才能退出程序
s.WaitOne(TimeSpan.FromSeconds(10));
NIM.ClientAPI.Cleanup();
}
Application.Exit();
}
}
private static void OnClientConnected(IAsyncResult result)
{
var state = result.AsyncState as Tuple <Socket, int>;
var socket = state.Item1;
try
{
socket.EndConnect(result);
if (socket.Connected)
{
m_Sockets[state.Item2] = socket;
}
}
catch
{
}
finally
{
m_ConnectSemaphore.Release();
}
if (socket.Connected)
{
StartTest(socket);
}
}
System.Threading.Semaphore semaphor = new System.Threading.Semaphore(1, 1);//信号灯，用于每次只能一个线程发送数据
/// <summary>
/// 发送数据到远端，线程入口
/// </summary>
/// <param name="data">发送数据</param>
private void SendToClient(object data)
{
try
{
semaphor.WaitOne();
byte[] bytes = (byte[])data;
this.networkStream.Write(bytes, 0, bytes.Length);
this.networkStream.Flush();
semaphor.Release();
}
catch
{
semaphor.Release();
}
}
void RenderSemPost()
{
if (!SingleLoop)
{
renderSem.Release();
}
}
public void MainSemPost()
{
if (!SingleLoop)
{
mainSem.Release();
}
}
public static CoalescedAnnounceResponse CoalescedAnnounce(this Tracker tracker, params IAnnounceRequest[] announceList)
{
InternalAnnounceResponseCollection annnounceResponses = new InternalAnnounceResponseCollection();
Semaphore requestSemaphore = new Semaphore(TrackerSettings.MaxConcurrency, TrackerSettings.MaxConcurrency);
IAsyncResult[] results = new IAsyncResult[announceList.Length];
for(int i = 0; i < announceList.Length; i++)
results[i] = tracker.BeginAnnounce(announceList[i], new AsyncCallback((result) => requestSemaphore.Release()), announceList[i].InfoHash);
foreach (IAsyncResult result in results)
{
IAnnounceResponse response = null;
try
{
response = tracker.EndAnnounce(result);
}
catch { }
if(response != null)
annnounceResponses.Add((InfoHash)result.AsyncState, new InternalAnnounceResponse(
response.Interval,
response.Complete,
response.Incomplete,
response.Peers)
);
}
return new CoalescedAnnounceResponse(annnounceResponses);
}
public override void EndScene()
{
try
{
if (form.Settings.RecentSplits.Any())
config.SetString("splitspath", form.Settings.RecentSplits.Last().Path);
if (form.Settings.RecentLayouts.Any())
config.SetString("layoutpath", form.Settings.RecentLayouts.Last());
var sem = new Semaphore(0, 1);
Action formCloseAction = () =>
{
form.TopMost = false;
while (form.Visible)
form.Close();
sem.Release();
};
if (form.InvokeRequired)
form.Invoke(formCloseAction);
else
formCloseAction();
sem.WaitOne();
}
catch (Exception ex)
{
Log.Error(ex);
API.Instance.Log(ex.Message);
API.Instance.Log(ex.StackTrace);
}
}
public WorkerResult StartUnmanaged()
{
WorkerResult ret = null;
Unmanaged worker = new Unmanaged();
Semaphore locker = new Semaphore(0, 1);
worker.OnCallback += (IEntity param) =>
{
ret = param as WorkerResult;
if (ret == null)
{
Console.WriteLine("erro no cast!");
}
else
{
Console.WriteLine("Id da classe: {0}", ret.Id);
}
locker.Release();
};
worker.DoSomething(2);
Console.WriteLine("Chamou o Unmanaged....");
locker.WaitOne();
return ret;
}
public static void MultualExclusiongUsingSemaphore() {
count = 0;
Semaphore writeSem = new Semaphore(1, 1);
answer.Clear();
Random executionLengthRand = new Random();
Thread[] threadArray = new Thread[1000];
for (int i = 0; i < 1000; i++)
{
threadArray[i] = new Thread(
() =>
{
int temp = -1;
executionLengthRand.Next(697);
writeSem.WaitOne();
count = count + 1;
temp = count;
executionLengthRand.Next(1937);
writeSem.Release();
answer.Push(temp);
}
);
threadArray[i].Start();
}
foreach (var t in threadArray)
{
t.Join();
}
foreach (var item in answer.Reverse())
{
Console.WriteLine(item);
}
}
public override bool Execute()
{
if (File.Exists(PropsFile) && File.Exists(TargetsFile))
{
return true;
}
string semaphoreName = PropsFile.ToUpper().GetHashCode().ToString("X");
bool releaseSemaphore;
using (Semaphore semaphore = new Semaphore(0, 1, semaphoreName, out releaseSemaphore))
{
try
{
if (!releaseSemaphore)
{
releaseSemaphore = semaphore.WaitOne(TimeSpan.FromMinutes(5));
return releaseSemaphore;
}
return GenerateBuildPackageImportFile();
}
finally
{
if (releaseSemaphore)
{
semaphore.Release();
}
}
}
}
/// <summary>
/// Konstruktor bezparametryczny
/// </summary>
public WidokMiniatur()
{
WyswietloneZdjecia = new List<IZdjecie>();
WszystkieZdjecia = new List<IZdjecie>();
katalogi = new Katalog[0];
tagi = new List<long>();
LargeImageList = new ImageList();
LargeImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
LargeImageList.Tag = "100%";
LargeImageList.TransparentColor = System.Drawing.Color.Transparent;
LargeImageList.ImageSize = new Size(Config.RozmiarMiniatury + 2, Config.RozmiarMiniatury + 2);
//Activate double buffering
//Enable the OnNotifyMessage event so we get a chance to filter out
// Windows messages before they get to the form's WndProc
this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
this.SetStyle(ControlStyles.EnableNotifyMessage, true);
katalog = Properties.Resources.katalog;
katalog_do_gory = Properties.Resources.katalog_do_gory;
Edycja = false;
sem = new Semaphore(0, 1);
sem.Release();
}
private void WriteToFile()
{
using System.Threading.Semaphore semaphore = new System.Threading.Semaphore(1, 1, "OS-übergreifende Semaphore");
semaphore.WaitOne();
File.AppendAllText(_fileName, $"{nameof(Semaphore)}: {DateTime.Now:hh:mm:ss:ffff} {Environment.NewLine}");
semaphore.Release();
}
protected override void OnStart(string[] args)
{
sem = new System.Threading.Semaphore(0, 1, "BatteryStatusChanging");
sem.Release();
Thread ServiceThread = new Thread(new ThreadStart(eventWait));
ServiceThread.Start();
}
// :$$$.отдатьсемафор
private static bool releaseSemaphore(System.Threading.Semaphore s, int p)
{
for (int i = 0; i < p; i++)
{
s.Release();
}
return(true);
}
public void Test()
{
Console.WriteLine("排队:" + Thread.CurrentThread.Name);
semahore.WaitOne();
Console.WriteLine(Thread.CurrentThread.Name);
Thread.Sleep(5000);
semahore.Release();
}
void DoStart()
{
TCallbackEvent callback = new TCallbackEvent();
callback.Func = 0;
m_CallbackSem.WaitOne();
try {
m_EventQueue.AddLast(callback);
}
finally {
m_CallbackSem.Release();
}
DoSetEvent();
}
public async static Task<List<winInfo>> Core(string SummonerName)
{
_sem = new Semaphore(0, 1);
_sem.Release();
await DoJSON(SummonerName);
List<winInfo> x = Stats.doStats(SummonerName);
return x;
}
private static async void longProccess(int i)
{
S.WaitOne();
Console.WriteLine($"Proceso {i} ejecutado");
await Task.Delay(1000);
semaphoreSlim.Release();
S.Release();
}
public static void ReleaseWriteLock(this Guid id, string name = "")
{
var sem = new Semaphore(maxReaders, maxReaders, id + name);
try
{
sem.Release(maxReaders);
}
catch (SemaphoreFullException) { }
}
public async void Start() {
run = true;
Task.Run(async () => {
try {
listener.Start();
} catch (Exception e) {
Console.Error.WriteLine("Failed to start server: " + e.Message);
return;
}
Semaphore sem = new Semaphore(MaxConnections, MaxConnections);
while (run) {
sem.WaitOne();
listener.GetContextAsync().ContinueWith(async (T) => {
HttpListenerContext context = await T;
try {
sem.Release();
// Test for route, 404 if not found
UrlRoute route = DiscoverRoute(context.Request.Url, context.Request.HttpMethod.ToUpperInvariant());
if (route == null) {
context.Response.StatusCode = 404;
byte[] str = System.Text.Encoding.UTF8.GetBytes(GetStatusPage(404, context.Request.Url, null));
context.Response.OutputStream.Write(str, 0, str.Length);
} else {
try {
// Execute response
HttpResponse response = await ProcessRequest(route, context);
try {
// Finish stuff up
response.Response.Close();
} catch (Exception e) {
context.Response.StatusCode = 500;
byte[] str = System.Text.Encoding.UTF8.GetBytes(GetStatusPage(500, context.Request.Url, e));
context.Response.OutputStream.Write(str, 0, str.Length);
} finally {
response.Close();
}
} catch (Exception e) {
context.Response.StatusCode = 500;
byte[] str = System.Text.Encoding.UTF8.GetBytes(GetStatusPage(500, context.Request.Url, e));
context.Response.OutputStream.Write(str, 0, str.Length);
}
}
} catch (Exception e) {
context.Response.StatusCode = 500;
byte[] str = System.Text.Encoding.UTF8.GetBytes(GetStatusPage(500, context.Request.Url, e));
context.Response.OutputStream.Write(str, 0, str.Length);
} finally {
context.Response.Close();
}
return;
});
}
listener.Stop();
listener.Close();
CleanUpAfterStop();
}).Wait();
}
static void Release(int number, Semaphore semaphore)
{
Console.WriteLine(String.Format("signalling {0}...", number));
try {
semaphore.Release(number);
} catch(SemaphoreFullException sx) {
Console.WriteLine("You're pressing the button too fast! Haven't finished signalling my max limit yet!");
}
}
public void Setup()
{
prosessingFinnishedSemaphore = new Semaphore(0, 1);
queue = new CommandQueue();
queue.ProcessingFinnished +=
delegate
{
prosessingFinnishedSemaphore.Release(1);
};
}
public void EventLoop_ScheduleAction()
{
var ran = false;
var gate = new Semaphore(0, 1);
var el = new EventLoopScheduler();
el.Schedule(() => { ran = true;
gate.Release(); });
Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
Assert.IsTrue(ran);
}
public void TestSelect()
{
RecommendManager.Instance.Init(@"data source=g:\database", "");
for (int i = 0; i < 180; i++)
{
Semaphore sm = new Semaphore(0, 1);
RecommendManager.Instance.RecommendCenter.GetRecommendsBySql(SQL(i), onRecommend, () => sm.Release(), onSqlError);
sm.WaitOne();
}
}
private void Worker(byte[] bear, int listID)
{
waitForLoop.Set();
bool sent = false;
while (!sent)
{
try
{
//Warten bis ein Workslot freigegeben wird
S.WaitOne();
//Debug-Output
Console.WriteLine("Sendethread gestartet! ID:" + listID);
try
{
// Erstellen des Sockets
Socket mysocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Verbindungsversuch, und neuversuch nach einer Sekunde bei misserfolg
bool connect = false;
while (!connect)
{
try
{
mysocket.Connect(_ipaddress, _port);
connect = true;
}
catch
{
Thread.Sleep(1000);
}
}
//Senden!
mysocket.Send(bear);
// Debug-Warten, um dem Server etwas Zeit zu geben.
Thread.Sleep(100);
// Schließen der Verbindung
mysocket.Close();
sent = true;
}
catch
{
Thread.Sleep(30);
}
}
finally
{
// Freigeben des Workslots
S.Release();
Console.WriteLine("Sendethread fertig.ID:" + listID);
}
}
}
public void Dispose()
{
if (iDisposed) return;
iDisposed = true;
Semaphore disabledSemaphore = new Semaphore(0, 1);
iDevice.SetDisabled(() => disabledSemaphore.Release());
disabledSemaphore.WaitOne();
((IDisposable)disabledSemaphore).Dispose();
iProvider.Dispose();
iDevice.Dispose();
}
private static void Main(string[] args)
{
var threads = new Thread[10];
for (var i = 0; i < 10; i++)
{
threads[i] = new Thread(Log);
}
for (var i = 0; i < 10; i++)
{
threads[i].Start();
}
semaphore.Release(4);
Console.ReadLine();
semaphore.Release(4);
Console.ReadLine();
semaphore.Release(4);
}
public void TestSemephore()
{
using (Semaphore m1 = new Semaphore(3,3, "MyAppLabel"))
{
//this will make any thread wait for 5 seconds if the app is already running to see if it stops running
m1.WaitOne();
//if the thread is done it can release the lock
m1.Release();
}
}
internal void Add(Message msg)
{
DataValue d = this.log.GetDataValue(schema, msg);
if (d != null)
{
next = d;
if (waiting)
{
available.Release();
}
}
}
public void EventLoop_DifferentThread()
{
var id = default(int);
var gate = new Semaphore(0, 1);
var el = new EventLoopScheduler();
el.Schedule(() =>
{
id = Thread.CurrentThread.ManagedThreadId;
gate.Release();
});
Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, id);
}
public void WaitRelease()
{
using (var semaphore = new Semaphore(2, 2))
{
var stopwatch = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
semaphore.WaitOne();
semaphore.Release();
}
stopwatch.StopAndLog(Iterations);
}
}
public void V()
{
//turn off interrupts
count++;
if (count <= 0)
{
//unblock
// var thread = threads.Dequeue() as Thread;
// thread.Resume();
realSemaphore.Release();
}
//turn on interrupts
}
public void EventLoop_ScheduleOrderedActions()
{
var results = new List<int>();
var gate = new Semaphore(0, 1);
var el = new EventLoopScheduler();
el.Schedule(() => results.Add(0));
el.Schedule(() =>
{
results.Add(1);
gate.Release();
});
Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
results.AssertEqual(0, 1);
}
public void ReleaseConnection(Driver driver)
{
lock (lockObject) {
inUsePool.Remove(driver);
}
if (driver.IsTooOld())
{
driver.Close();
}
else
{
lock (lockObject) {
idlePool.Enqueue(driver);
}
}
// we now either have a connection available or have room to make
// one so we release one slot in our semaphore
if (Interlocked.Increment(ref counter) <= 0)
{
poolGate.Release();
}
}
public async Task ConnectAsync(string host, int port)
{
_Smp.WaitOne();
if (!Connected)
{
try
{
client.Close();
client = new TcpClient();
await client.ConnectAsync(host, port);
nstream = client.GetStream();
}
catch
{
_Smp.Release();
throw;
}
_Smp.Release();
StartReceive();
return;
}
_Smp.Release();
}
static void SemaphoreMultiplex()
{
counter = 0;
Semaphore multiple = new Semaphore(0, 10);
multiple.Release();
ConcurrentQueue<int> answer = new ConcurrentQueue<int>();
//multiple.
Random ex = new Random();
Thread[] array = new Thread[50];
for (int i = 0; i < 50; i++)
{
array[i] = new Thread(
() =>
{
multiple.WaitOne();
counter = 1 + counter;
Thread.Sleep(ex.Next(67));
multiple.Release();
answer.Enqueue(counter);
}
);
array[i].Start();
}
foreach (var t in array)
{
t.Join();
}
var s = answer.Distinct();
foreach (var t in answer)
{
Console.WriteLine("count {0} and t {1}", t, answer.Count());
};
}
public void Run(IAsyncRequestHandler requestHandler)
{
Task.Run(() =>
{
try
{
// Start the HTTP listener:
_listener.Start();
}
catch (HttpListenerException hlex)
{
Console.Error.WriteLine(hlex.Message);
return;
}
// Accept connections:
// Higher values mean more connections can be maintained yet at a much slower average response time; fewer connections will be rejected.
// Lower values mean less connections can be maintained yet at a much faster average response time; more connections will be rejected.
var sem = new Semaphore(_accepts, _accepts);
while (true)
{
sem.WaitOne();
#pragma warning disable 4014
_listener.GetContextAsync().ContinueWith(async (t) =>
{
string errMessage;
try
{
sem.Release();
var ctx = await t;
await ProcessListenerContext(ctx, requestHandler);
return;
}
catch (Exception ex)
{
errMessage = ex.ToString();
}
await Console.Error.WriteLineAsync(errMessage);
});
#pragma warning restore 4014
}
}).Wait();
}
public void start()
{
semaphore.WaitOne();
int cashRegisterId = que.reserveCashRegister(id);
System.Threading.Thread.Sleep(new Random().Next(100, 4000));
que.account.deposit(moneyToSpend);
que.releaseCashRegister(id, cashRegisterId);
semaphore.Release();
barrier.SignalAndWait();
}
public static async void TempAction (Object obj) {
var client = ThirdPartyLibrary.ClientManager.CreateClient ();
await client.Authenticate ("villians-db", "justice-league");
Semaphore sem = new Semaphore (1, 1);
foreach (var kvp in fields) {
sem.WaitOne ();
client.RequestData (kvp.Key, (succ, fields, values) => {
if(!succ) {
Console.WriteLine("Error communicating");
}
values.ForEach(value => Console.WriteLine(value));
sem.Release();
});
}
((Barrier)obj).SignalAndWait ();
}
public static void Main()
{
_pool = new Semaphore(0, 3);
for (var i = 1; i <= 5; i++)
{
var t = new Thread(Worker);
t.Start(i);
}
Thread.Sleep(500);
logger.Log("Main thread calls Release(3).");
_pool.Release(3);
logger.Log("Main thread exits.");
}
static void Main(string[] args)
{
var mutex = new Mutex(false, "my_mytex");
var sw = Stopwatch.StartNew();
for(int i = 0; i < 1000 * 1000; i++)
{
mutex.WaitOne();
mutex.ReleaseMutex();
}
Console.WriteLine(sw.ElapsedMilliseconds);
var sem = new Semaphore(1, 1, "my_semaphore");
sw.Restart();
for(int i = 0; i < 1000 * 1000; i++)
{
sem.WaitOne();
sem.Release();
}
Console.WriteLine(sw.ElapsedMilliseconds);
var mre = new EventWaitHandle(true, EventResetMode.ManualReset, "my_manual_reset_event");
sw.Restart();
for(int i = 0; i < 1000 * 1000; i++)
{
mre.WaitOne();
mre.Set();
}
Console.WriteLine(sw.ElapsedMilliseconds);
var are = new EventWaitHandle(true, EventResetMode.AutoReset, "my_auto_reset_event");
sw.Restart();
for(int i = 0; i < 1000 * 1000; i++)
{
are.WaitOne();
are.Set();
}
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Restart();
for(int i = 0; i < 1000 * 1000; i++)
{
Monitor.Enter(sw);
Monitor.Exit(sw);
}
Console.WriteLine(sw.ElapsedMilliseconds);
}
public async Task Should_raise_email_received_event()
{
var msg = CreateMessage();
using (var sut = GetSut())
using (var semaphore = new Semaphore(0, 1))
using (sut.EmailReceived.Subscribe(actual =>
{
AssertEmailsAreEqual(actual, msg);
semaphore.Release();
}))
{
await SendEmailsAsync(sut, msg);
semaphore.WaitOne();
}
}
public void bw_DoWork(object sender, DoWorkEventArgs e)
{
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(ipep);
server.Listen(10);
// 1. listen
while (true)
{
semaphor.WaitOne();
Socket _socket = server.Accept(); //chờ đợi client kết nối đến
client = new ClientManager(this, _socket); //tạo client giữa server với client vừa kết nối để giữ liên lạc
// 2. Nhận thông tin tài khoản được gởi đến từ bên client
semaphor.Release();
}
//kết thúc lắng nghe
}
//Worker Methode
private void Worker(DirectoryInfo workDir, string client, ref List <byte[]> subxmls, string savePath)
{
try
{
//Warten bis ein Workslot freigegeben wird
S.WaitOne();
//Let's do this ... LEEEEROY JENKINS !!!
Console.WriteLine("Thread " + workDir + " hat gestartet");
//Anlegen des XML Baums mit dem client Root-Tag
XElement tree = new XElement("client", new XAttribute("name", client));
//Zusammenbau eines XDocuments aus XElement und XDeclaration
XDocument rootXMLdoc = new XDocument(
new XDeclaration("1.0", "utf-8", "yes"),
tree);
//Ausführen der XML-GeneratorMethode
tree.Add(GetDirectoryXML(workDir));
//Speichern des XDocuments in der Liste
//Erfolgreicher Test: Speichern mittels XmlWriter, dann einlesen mittel ReadAllBytes. Nicht schön, aber praktisch --> Debugging
string savename = savePath + workDir + ".xml";
XmlWriterSettings settings = new XmlWriterSettings();
//UTF8Encoding: True = mit BOM , False = ohne BOM (BOM = Byte Order Marker) --> False löst das "???" Problem am Anfang der Dateien
settings.Encoding = new UTF8Encoding(false);
settings.Indent = true;
settings.NewLineOnAttributes = false;
using (XmlWriter w = XmlWriter.Create(savename, settings))
{
tree.Save(w);
}
subxmls.Add(File.ReadAllBytes(savename));
}
finally
{
//Freigeben des Workslots
S.Release();
//Debug Output - Signalisiern, dass der Thread fertig ist
Console.WriteLine("Thread " + workDir + " ist fertig");
}
}
public void TestMultiThreading()
{
var threads = new Thread[4];
int messageLength = 2;
int maxNumMessages = 1024 * 1024 - 1;
using (ThreadSafeWriteQueue b = new ThreadSafeWriteQueue(threads.Length * messageLength * maxNumMessages))
{
using (Semaphore semaphore = new Semaphore(0, threads.Length))
{
var messagesPerThread = maxNumMessages;
for (int index = 0; index < threads.Length; index++)
{
var thread = threads[index] = new Thread(this.WriteProc);
thread.Start(new Context { Buffer = b, Semaphore = semaphore, Count = messagesPerThread, Id = index });
}
semaphore.Release(threads.Length);
var t1 = DateTime.Now;
foreach (var thread in threads)
{
thread.Join();
}
var t2 = DateTime.Now;
Console.WriteLine(
"{0} sec ({1} per sec)",
t2.Subtract(t1).TotalSeconds,
messagesPerThread * threads.Length / t2.Subtract(t1).TotalSeconds);
int count = 0;
int[] countsPerThread = new int[threads.Length];
int pos;
while ((pos = b.ReadMessage()) >= 0)
{
++countsPerThread[b.ReadInt32(pos)];
++count;
}
for (int index = 0; index < countsPerThread.Length; index++)
{
Console.WriteLine("Thread {0} sent {1} messages", index, countsPerThread[index]);
}
Assert.AreEqual(messagesPerThread * threads.Length, count);
}
}
}
//private var semaphore = new System.Threading.Semaphore(this.max_thread, this.max_thread);
public void StartConvertAndWrite(MyClass_Files_Writer fileWriter, string srcString, char delimiter, int fieldNumber)
{
System.Threading.ThreadPool.QueueUserWorkItem((state) =>
{
semaphore.WaitOne(); // 세마포어 wait
try
{
//DownloadItem(item);
var t = new System.Threading.Thread(() => RealStart(fileWriter, srcString, delimiter, fieldNumber));
t.Start();
//return t;
}
finally
{
semaphore.Release(); // 세마포어 end
}
});
}
public void Read()
{
while (count > 0)
{
sem.WaitOne();
Console.WriteLine("{0} entered", Thread.CurrentThread.Name);
Console.WriteLine("{0} reading...", Thread.CurrentThread.Name);
Thread.Sleep(1000);
Console.WriteLine("{0} go away", Thread.CurrentThread.Name);
sem.Release();
count--;
Thread.Sleep(1000);
}
}
public void PingPong()
{
// Create names for the two semaphores
string outboundName = Guid.NewGuid().ToString("N");
string inboundName = Guid.NewGuid().ToString("N");
// Create the two semaphores and the other process with which to synchronize
using (var inbound = new Semaphore(1, 1, inboundName))
using (var outbound = new Semaphore(0, 1, outboundName))
using (var remote = RemoteInvoke(PingPong_OtherProcess, outboundName, inboundName))
{
// Repeatedly wait for count in one semaphore and then release count into the other
for (int i = 0; i < 10; i++)
{
Assert.True(inbound.WaitOne(FailWaitTimeoutMilliseconds));
outbound.Release();
}
}
}
public void Run(params string[] uriPrefixes) {
// Establish a host-handler context:
_listener.IgnoreWriteExceptions = true;
// Add the server bindings:
foreach (var prefix in uriPrefixes)
_listener.Prefixes.Add(prefix);
Task.Run(async () => {
// Initialize the handler:
try {
// Start the HTTP listener:
_listener.Start();
} catch (HttpListenerException hlex) {
Console.Error.WriteLine(hlex.Message);
return;
}
var sem = new Semaphore(_accepts, _accepts);
while (true) {
sem.WaitOne();
_listener.GetContextAsync().ContinueWith(async (t) => {
string errMessage;
try {
sem.Release();
Console.WriteLine("Connected");
var ctx = await t;
await ProcessListenerContext(ctx);
return;
} catch (Exception ex) {
errMessage = ex.ToString();
}
await Console.Error.WriteLineAsync(errMessage);
});
}
}).Wait();
}
static void Main(string[] args)
{
bool createdNew;
_semaphore = new Semaphore(0, 3, "SemaphoreTest", out createdNew);
if (createdNew)
{
Thread.Sleep(1000);
//退出信号量三次，并且计数加三
_semaphore.Release(3);
}
for (int i = 0; i < 10; i++)
{
Thread t = new Thread(new ParameterizedThreadStart(Worker));
t.Start(i);
}
Console.Read();
}
public async Task Start()
{
using (var listener = new HttpListener())
{
listener.Prefixes.Add(string.Format("http://+:{0}/", this.port));
listener.Start();
Console.WriteLine("Listening on port {0}", port);
var semaphore = new Semaphore(listenerCount, listenerCount);
while (true)
{
semaphore.WaitOne();
var context = await listener.GetContextAsync();
semaphore.Release();
await Task.Factory.StartNew(() => Handler(context));
}
}
}
public bool SetTimeUpdatePeriod(uint sec)
{
bool rst = false;
reg_semaphore.WaitOne();
if (reg != null)
{
try
{
reg.SetValue("time_update_period", sec, RegistryValueKind.DWord);
reg.Flush();
rst = true;
}catch (Exception e)
{
Console.WriteLine(e);
}
}
reg_semaphore.Release();
return(rst);
}
private void OnBatteryStatusChange(UInt16 newStatus)
{
sem.WaitOne();
if (newStatus == 1)
{
// "The computer was unplugged.";
foreach (string serviceName in services)
{
StopService(serviceName, 15000);
}
}
else if (newStatus == 2)
{
// "The computer was plugged in.";
foreach (string serviceName in services)
{
StartService(serviceName, 15000);
}
}
sem.Release();
}
static int Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException +=
new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
Directory.SetCurrentDirectory(Path.GetDirectoryName(Application.ExecutablePath));
toUpdateLog("started\r\n" + stringArrayToLogString(args, "\t"));
if (!s.WaitOne(0))
{
Console.WriteLine("semaphore locked to umove.exe; exited");
toUpdateLog("semaphore locked to umove.exe; exited");
return(3);
}
var umove = false;
try
{
argsString = getArgumentsFromArgArray(args);
if (args.Length == 1 && args[0] == "-umove")
{
var result = umoveRename();
toUpdateLog("-umove");
umove = true;
}
else
{
umoveRename();
}
if (args.Length == 1 && args[0] == "-v")
{
AllocConsole();
Console.WriteLine(version);
Console.ReadKey();
FreeConsole();
return(0);
}
createOrParseIni();
var uuPath = downloadUpdate(Directory.GetCurrentDirectory(), opts["updatorDir", ""].Replace("$$$", "update"), "update", version, args);
if (!String.IsNullOrEmpty(uuPath))
{
try
{
File.WriteAllText("uup.flag", Path.GetFullPath(uuPath) + "\r\n");
Process.Start("umove.exe", "uup.flag \"vs8.ru updator semaphore\" 50 \"\"");
}
catch (Exception e)
{
toUpdateLog(e.Message + "\r\n" + e.StackTrace);
}
}
if (umove)
{
return(51);
}
if (
args.Length > 3 || args.Length < 3 ||
(args.Length == 1 && (args[0] == "-?" || args[0] == "/?" || args[0] == "/help" || args[0].ToLower() == "--help"))
)
{
AllocConsole();
Console.WriteLine("updatorvs8.exe updateName version path_to_dwnl");
Console.WriteLine("for example: updatorvs8.exe relaxtime 20110929 D:/rtbd/");
Console.WriteLine("warning: umove.exe must be place to same directory updatorvs8.exe");
Console.ReadKey();
FreeConsole();
return(1);
}
var dirName = args[2];
if (!Directory.Exists(dirName))
{
Console.WriteLine(String.Format("update directory '{0}' is not exists", args[1]));
return(2);
}
var updateFlagFile = Path.Combine(new string[] { dirName, "update.flag" });
File.Delete(updateFlagFile);
var updatedPath =
downloadUpdate(dirName, opts["updateDir", ""].Replace("$$$", args[0]), args[0], args[1], args);
var updated = !String.IsNullOrEmpty(updatedPath);
if (updated)
{
File.WriteAllText(updateFlagFile, Path.GetFullPath(updatedPath) + "\r\n");
Console.WriteLine("success");
toUpdateLog("success");
if (args[0] == "relaxtime")
{
try
{
var resp = new response();
resp.getFile("http://mc.yandex.ru/watch/15915832", @"http://relaxtime.8vs.ru/success.html?guid=" + opts["updatorGUID"]);
}
catch (Exception e)
{
toUpdateLog("success and error: " + e.Message);
}
}
}
else
{
if (updatedPath == null)
{
Console.WriteLine("failure");
toUpdateLog("failure");
if (args[0] == "relaxtime")
{
try
{
var resp = new response();
resp.getFile("http://mc.yandex.ru/watch/15915832", @"http://relaxtime.8vs.ru/failure.html?guid=" + opts["updatorGUID"]);
}
catch (Exception e)
{
toUpdateLog("failure and error: " + e.Message);
}
}
}
else
{
Console.WriteLine("neutral");
toUpdateLog("neutral");
if (args[0] == "relaxtime")
{
try
{
var resp = new response();
resp.getFile("http://mc.yandex.ru/watch/15915832", @"http://relaxtime.8vs.ru/neutral.html?guid=" + opts["updatorGUID"]);
}
catch (Exception e)
{
toUpdateLog("neutral and error: " + e.Message);
}
}
}
}
toUpdateLog("ended");
var fi = new FileInfo(updatorLogFileName);
truncateLog(fi);
if (updated)
{
return(0);
}
else
{
return(11);
}
}
finally
{
s.Release();
s.Close();
}
}
private void bwSender_DoWork(object sender, DoWorkEventArgs e)
{
Command cmd = (Command)e.Argument;
byte[] buffer = new byte[4];
byte[] metaBuffer;
byte[] data;
byte[] dataPicture;
int lenght;
semaphor.WaitOne();
try
{
if (cmd.CommandType == CommandType_.Message)
{
if (cmd.commandBody == null || cmd.commandBody == "")
{
cmd.commandBody = "\n";
}
metaBuffer = Encoding.ASCII.GetBytes(cmd.commandBody);
//gởi thông điệp là tin nhắn cho bên nhận biết
buffer = BitConverter.GetBytes((int)CommandType_.Message);
stream.Write(buffer, 0, 4);
stream.Flush();
//gởi nội dung tin nhắn
buffer = BitConverter.GetBytes(metaBuffer.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
this.stream.Write(metaBuffer, 0, cmd.commandBody.Length);
this.stream.Flush();
//convert font để gởi
MemoryStream s = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(s, cmd.Fontsyle);
//send font
metaBuffer = new byte[1024];
metaBuffer = s.ToArray();
buffer = BitConverter.GetBytes(metaBuffer.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
stream.Write(metaBuffer, 0, metaBuffer.Length);
this.stream.Flush();
}
if (cmd.CommandType == CommandType_.LoadMessage)
{
buffer = BitConverter.GetBytes((int)CommandType_.LoadMessage);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes(cmd.commandBody.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
metaBuffer = Encoding.ASCII.GetBytes(cmd.commandBody);
this.stream.Write(metaBuffer, 0, cmd.commandBody.Length);
this.stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.count);
stream.Write(buffer, 0, 4);
stream.Flush();
}
if (cmd.CommandType == CommandType_.MessageFriend)
{
if (cmd.commandBody == null || cmd.commandBody == "")
{
cmd.commandBody = "\n";
}
metaBuffer = Encoding.ASCII.GetBytes(cmd.commandBody);
//gởi thông điệp là tin nhắn cho bên nhận biết
buffer = BitConverter.GetBytes((int)CommandType_.MessageFriend);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.Username.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.Username);
stream.Write(data, 0, data.Length);
stream.Flush();
//gởi nội dung tin nhắn
buffer = BitConverter.GetBytes(metaBuffer.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
this.stream.Write(metaBuffer, 0, cmd.commandBody.Length);
this.stream.Flush();
//convert font để gởi
MemoryStream s = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(s, cmd.Fontsyle);
//send font
metaBuffer = new byte[1024];
metaBuffer = s.ToArray();
buffer = BitConverter.GetBytes(metaBuffer.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
stream.Write(metaBuffer, 0, metaBuffer.Length);
this.stream.Flush();
}
if (cmd.CommandType == CommandType_.ListFriend)
{
buffer = BitConverter.GetBytes((int)CommandType_.ListFriend);
stream.Write(buffer, 0, 4);
stream.Flush();
}
if (cmd.CommandType == CommandType_.ChangeInformation)
{
buffer = BitConverter.GetBytes((int)CommandType_.ChangeInformation);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.Email.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.Email);
stream.Write(data, 0, data.Length);
stream.Flush();
//gởi avatar cho user
dataPicture = (byte[])cmd.Image_;
buffer = BitConverter.GetBytes(dataPicture.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
SendLargeFile(dataPicture, stream);
stream.Flush();
//gởi status
data = Encoding.UTF8.GetBytes(cmd.Status);
buffer = BitConverter.GetBytes(data.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
SendLargeFile(data, stream);
stream.Flush();
}
//gởi thông điệp lên server kiểm tra xem tên này có trong CSDL ko
if (cmd.CommandType == CommandType_.FindFriend)
{
metaBuffer = Encoding.ASCII.GetBytes(cmd.Username);
//gởi thông điệp là tin nhắn cho bên nhận biết
buffer = BitConverter.GetBytes((int)CommandType_.FindFriend);
stream.Write(buffer, 0, 4);
stream.Flush();
//gởi nội dung tin nhắn
buffer = BitConverter.GetBytes(cmd.Username.Length);
stream.Write(buffer, 0, 4);
this.stream.Flush();
this.stream.Write(metaBuffer, 0, cmd.Username.Length);
this.stream.Flush();
}
if (cmd.CommandType == CommandType_.LoadNotice)
{
buffer = BitConverter.GetBytes((int)CommandType_.LoadNotice);
stream.Write(buffer, 0, 4);
stream.Flush();
}
if (cmd.CommandType == CommandType_.AddNotice)
{
buffer = BitConverter.GetBytes((int)CommandType_.AddNotice);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserPrimary.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserPrimary);
stream.Write(data, 0, data.Length);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserReference.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserReference);
stream.Write(data, 0, data.Length);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.Type.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.Type);
stream.Write(data, 0, data.Length);
stream.Flush();
}
if (cmd.CommandType == CommandType_.AddFriend)
{
buffer = BitConverter.GetBytes((int)CommandType_.AddFriend);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserPrimary.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserPrimary);
stream.Write(data, 0, data.Length);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserReference.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserReference);
stream.Write(data, 0, data.Length);
stream.Flush();
for (int i = 0; i < Notice_frm.listNotice.Count; i++)
{
if (Notice_frm.listNotice[i]._userPrimary == cmd.UserPrimary && Notice_frm.listNotice[i]._userReference == cmd.UserReference)
{
Notice_frm.listNotice.Remove(Notice_frm.listNotice[i]);
}
}
}
if (cmd.CommandType == CommandType_.DeleteNotice)
{
buffer = BitConverter.GetBytes((int)CommandType_.DeleteNotice);
stream.Write(buffer, 0, 4);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserPrimary.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserPrimary);
stream.Write(data, 0, data.Length);
stream.Flush();
buffer = BitConverter.GetBytes((int)cmd.UserReference.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = Encoding.ASCII.GetBytes(cmd.UserReference);
stream.Write(data, 0, data.Length);
stream.Flush();
for (int i = 0; i < Notice_frm.listNotice.Count; i++)
{
if (Notice_frm.listNotice[i]._userPrimary == cmd.UserPrimary && Notice_frm.listNotice[i]._userReference == cmd.UserReference)
{
Notice_frm.listNotice.Remove(Notice_frm.listNotice[i]);
}
}
}
}
catch
{
}
semaphor.Release();
}
