public async Task UpdateThreadsAsync()
{
var httpClient = new HttpClient(new HttpClientLoggingHandler(new HttpClientHandler()));
var response = await httpClient.GetAsync(Url + RecentUrl);
var document = await new HtmlParser().ParseDocumentAsync(await response.Content.ReadAsStringAsync());
var liElements = document.QuerySelectorAll("#thread_index > li");
var realm = Realm.GetInstance();
realm.Write(() =>
{
foreach (var liElement in liElements)
{
var threadTitle = liElement.QuerySelector("a").TextContent;
var thread = Threads.Where(o => o.ThreadTitle == threadTitle).FirstOrDefault();
if (thread == null)
{
thread = new ThreadRealmObject
{
ThreadTitle = threadTitle,
Node = this,
};
Threads.Add(thread);
}
thread.ThreadModifiedDateTime = DateTimeOffset.Parse(liElement.QuerySelector(".stamp").TextContent);
}
});
}
//Открыть поток реального времени, управляемы очередью прокси
private ProxyThread OpenProxyThread(int id, string name, QueuedProxyConnect proxy)
{
var t = new ProxyThread(this, id, name, null, proxy);
Threads.Add(id, t, true);
return(t);
}
public void StartRace()
{
if (Bolides.Count == 0)
{
throw new Exception("Вы не добавили ни одного участника!");
}
if (RaceIsOn)
{
throw new Exception("Гонка уже началась!");
}
foreach (Bolide b in Bolides)
{
b.RequestCleaning += Cleaning;
b.RequestRepairing += BolideBroken;
Thread thread = new Thread(() => b.Drive());
thread.IsBackground = true;
Threads.Add(thread);
}
foreach (Thread t in Threads)
{
t.Start();
}
RaceIsOn = true;
}
//Открыть поток реального времени
private RealTimeThread OpenRealTimeThread(int id, string name, double periodSeconds, double lateSeconds = 0)
{
var t = new RealTimeThread(this, id, name, null, periodSeconds, lateSeconds);
Threads.Add(id, t, true);
return(t);
}
private void AddThread(object obj)
{
lock (_locker)
{
Threads.Add(new ThreadInfo());
}
}
public void StartThread()
{
Log.InfoFormat("开始启动任务处理【队列类型:{0} 队列数量:{1}】", this.TaskQueueType, TaskQueueCount.ToString());
var queues = MessageContainer.GetTaskQueues(TaskQueueType, TaskQueueCount);
foreach (var queue in queues)
{
Threads.Add(StartThread(queue, Log));
}
//守护线程，确保启动的线程处于工作状态(每60秒检查一次）
this.timer = new System.Timers.Timer(1000 * 60)
{
AutoReset = true
};
timer.Elapsed += (sender, evertArgs) =>
{
if (this.Stopped)
{
return;
}
this.EnsureAlive();
};
timer.Start();
}
//Открыть разовый поток
public SingleThread OpenSingleThread(int id, string name)
{
var t = new SingleThread(this, id, name, new AppIndicator());
Threads.Add(id, t, true);
return(t);
}
/// <summary>借用线程</summary>
/// <returns></returns>
private ThreadX Open()
{
lock (SyncLock_Threads)
{
foreach (ThreadX item in Threads)
{
if (item != null && item.IsAlive && !item.Running)
{
return(item);
}
}
//没有空闲线程，加一个
if (Threads.Count < MaxThreads)
{
ThreadX thread = AddThread();
Threads.Add(thread);
RunningCount++;
return(thread);
}
else
{
WriteLog("已达到最大线程数！");
}
}
return(null);
}
//Открыть периодический поток
public PeriodicThread OpenPeriodicThread(int id, string name, double periodMinutes, double lateMainutes = 0)
{
var t = new PeriodicThread(this, id, name, new AppIndicator(), periodMinutes, lateMainutes);
Threads.Add(id, t, true);
return(t);
}
/// <summary>
/// Add's a <c>ThreadStarter</c> element to the internal thread list
/// </summary>
/// <remarks>
/// Raises the <see cref="ThreadAdded" /> event.
/// </remarks>
/// <param name="thread">The ThreadStarter element to add</param>
private static void RegisterThread(ThreadStarter thread)
{
Threads.Add(thread);
if (ThreadAdded != null)
{
ThreadAdded(null, thread);
}
}
public void StartThread(string name, ThreadableClass <string> threadableobject)
{
Threads.Add(threadableobject.ID, new Thread(threadableobject.Start));
Objects.Add(threadableobject.ID, threadableobject);
Threads[threadableobject.ID].Start();
Threads[threadableobject.ID].Name = name;
Threads[threadableobject.ID].IsBackground = true;
}
public bool AddThread(Thread thread)
{
thread.Created = new DateTime(DateTime.Now.Ticks);
thread.Locked = false;
Threads.Add(thread);
return(true);
}
internal async Task BindAsync()
{
// TODO: Move thread management to LibuvTransportFactory
// TODO: Split endpoint management from thread management
for (var index = 0; index < TransportOptions.ThreadCount; index++)
{
Threads.Add(new LibuvThread(Libuv, TransportContext));
}
foreach (var thread in Threads)
{
await thread.StartAsync().ConfigureAwait(false);
}
try
{
if (TransportOptions.ThreadCount == 1)
{
var listener = new Listener(TransportContext);
_listeners.Add(listener);
await listener.StartAsync(EndPoint, Threads[0]).ConfigureAwait(false);
EndPoint = listener.EndPoint;
}
else
{
var pipeName = (Libuv.IsWindows ? @"\\.\pipe\kestrel_" : "/tmp/kestrel_") + Guid.NewGuid().ToString("n");
var pipeMessage = Guid.NewGuid().ToByteArray();
var listenerPrimary = new ListenerPrimary(TransportContext);
_listeners.Add(listenerPrimary);
await listenerPrimary.StartAsync(pipeName, pipeMessage, EndPoint, Threads[0]).ConfigureAwait(false);
EndPoint = listenerPrimary.EndPoint;
foreach (var thread in Threads.Skip(1))
{
var listenerSecondary = new ListenerSecondary(TransportContext);
_listeners.Add(listenerSecondary);
await listenerSecondary.StartAsync(pipeName, pipeMessage, EndPoint, thread).ConfigureAwait(false);
}
}
_acceptEnumerator = AcceptConnections();
}
catch (UvException ex) when(ex.StatusCode == LibuvConstants.EADDRINUSE)
{
await UnbindAsync().ConfigureAwait(false);
throw new AddressInUseException(ex.Message, ex);
}
catch
{
await UnbindAsync().ConfigureAwait(false);
throw;
}
}
public void makeThread(string thread, string post, string user, string section)
{
var s = Sections.Where(s => s.Name == section).FirstOrDefault();
Threads.Add(new Thread {
name = thread, post = post, author = GetUserByName(user), section = s
});
SaveChanges();
}
public static bool Start()
{
//ListenerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
OpenYS.OpenYSConsole.YSFClient.OpenYSSupport = Settings.Options.AllowOYSFramework;
OpenYS.OpenYSConsole.SetLoggedIn();
ListenerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ServerClosed = new ManualResetEvent(false);
ServerListenerThread = Threads.Add(() => _Start(), "Server Listener Thread");
return(true);
}
//Загрузка потока контроллера
public void AddThread(IRecordRead rec)
{
var t = new ThreadController(rec)
{
App = this, Synchro = Synchro
};
ThreadsDic.Add(t.Id, t);
Threads.Add(t);
MonitorHistory.AddHistoryTables(t.Id);
}
public void Start()
{
Running = true;
StartTime = DateTime.Now;
int countA = 0;
int countB = 0;
int countC = 0;
int countD = 0;
foreach (Room room in Rooms)
{
Category category = room.Category;
switch (category)
{
case Category.A:
countA++;
break;
case Category.B:
countB++;
break;
case Category.C:
countC++;
break;
case Category.D:
countD++;
break;
}
}
LimitA = countA;
LimitB = countB;
LimitC = countC;
LimitD = countD;
managePatientsThread = new Thread(ManagePatients);
//Thread navigatePatientsThread = new Thread(NavigatePatients);
dischargePatientsThread = new Thread(DischargePatients);
//Thread navigateToExit = new Thread(NavigateToExit);
Threads.Add(managePatientsThread);
//Threads.Add(navigatePatientsThread);
Threads.Add(dischargePatientsThread);
managePatientsThread.Start();
//navigatePatientsThread.Start();
dischargePatientsThread.Start();
//navigateToExit.Start();
}
public void Start(int count)
{
for (var index = 0; index != count; ++index)
{
Threads.Add(new KestrelThread(this));
}
foreach (var thread in Threads)
{
thread.StartAsync().Wait();
}
}
private void GatherThreadData(IThreadDataSource threadDataSource)
{
foreach (IThread thread in threadDataSource.Threads)
{
Process process = new Process(thread.Process.Id, thread.Process.ImageName);
if (!Threads.ContainsKey(process))
{
Threads.Add(process, new List <Thread>());
}
Threads[process].Add(new Thread(thread.Id));
}
}
public void Start()
{
NetworkT.Start();
for (int i = 0; i < MaxThreads; i++)
{
Threads.Add(new Thread(new ThreadStart(StartHandlerThread)));
}
foreach (var i in Threads)
{
i.Start();
}
}
public Thread InsertThread(string title, string content)
{
var currentUser = System.Threading.Thread.CurrentPrincipal.Identity.Name;
var thread = new Thread
{
Title = title,
Started = DateTime.UtcNow,
StartedBy = currentUser,
LastPost = DateTime.UtcNow,
LastPostBy = currentUser
};
Threads.Add(thread);
SaveChanges();
return(thread);
}
//-----------------------------------------------------------------------------------------------
/// <summary>
/// Starts the given thread
/// </summary>
/// <param name="thread">thread to start</param>
public virtual void StartThread(GThread thread)
{
/// May 10, 2006 [email protected]: Fix for bug 1482578
/// Prevents the client from executing StartThread on single-use
/// applications. StartThread should only be called for starting
/// on-the-fly threads to multi-use applications.
if (!_MultiUse)
{
throw new InvalidOperationException("Cannot use StartThread with single-use GApplication objects.");
}
Init();
Threads.Add(thread);
SetThreadOnManager(thread);
StartGetFinishedThreads();
}
public void CreateLoadThreads(int num)
{
int numPerThread = (int)Math.Ceiling(Math.Max(((float)Worlds.Count / (float)num), 1.0f));
for (int i = 0; i < num; i++)
{
int min = Math.Min((numPerThread) * i, Worlds.Count);
int max = Math.Min(min + numPerThread, Worlds.Count);
if (max - min > 0)
{
Thread loadThread = new Thread(() => WorldLoaderThread(min, max));
loadThread.Start();
Threads.Add(loadThread);
}
}
}
public override async Task Run()
{
this.Configurations.ForEach(config =>
{
var configTask = new Task(() =>
{
Thread.Sleep(config.Wait);
OnTriggered(config);
});
Threads.Add(config, configTask);
});
Threads.Values.ForEach(t => t.Start());
Task.WaitAll(Threads.Values.ToArray());
}
private void StartThreads()
{
foreach (var car in Cars)
{
Thread carThread = new Thread(new ParameterizedThreadStart(Ride))
{
Name = car.Name
};
Threads.Add(carThread);
}
for (int i = 0; i < Threads.Count; i++)
{
Threads[i].Start(Cars[i]);
Cars[i].Time.Start();
}
}
private void GetThreadsFromDocument(XmlNode document)
{
XmlNode element = document.FirstChild;
if (element == null || element.Name != "root")
{
throw new XmlException();
}
foreach (XmlElement childElement in element.ChildNodes)
{
Thread thread = Thread.GetThreadFromElement(childElement);
Threads.Add(thread);
}
IsSave = true;
}
public void Configure()
{
Threads.Add(new Thread(new ParameterizedThreadStart(ProcessThread))
{
Name = "PROC",
IsBackground = true,
});
Threads.Add(new Thread(new ParameterizedThreadStart(GarbageCycleThread))
{
Name = "GARC",
IsBackground = true
});
// TODO: Read configuration.
State = ServerState.Stopped;
Log.Info("Server configuration loaded");
}
/// <summary>
/// Connect to twitch service with provided username and password.
/// </summary>
/// <param name="channel">Channel for the bot to write messages and/or moderate.</param>
/// <remarks>Passwords meaning your provided token.</remarks>
/// <returns>True whether could connect otherwise false.</returns>
public async Task ConnectAsync(string channel)
{
try
{
ServiceThread st = new ServiceThread(channel);
st.Thread = new Thread(async() =>
{
try
{
while (!st.CancellationToken.IsCancellationRequested)
{
if (TCPClient.Available > 0 || Reader.Peek() >= 0)
{
var message = await Reader.ReadLineAsync();
OnMessageReceived(new MessageReceivedEventArgs(message, channel));
}
st.CancellationToken.Token.ThrowIfCancellationRequested();
}
}
catch (OperationCanceledException)
{
Debug.WriteLine($"[*] Thread ({st.Channel}) has stopped working, through a cancellation request.");
}
});
st.Start();
// join chatroom
await SendMessageAsync(
message : $"JOIN #{channel.ToLower()}",
systemMessage : true
);
Threads.Add(st);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
public void Setup(int threadCount, TableMap[] maps)
{
var th = Threads.ToArray();
foreach (var workThread in th)
{
workThread.Stop();
}
Threads.Clear();
_allMaps.Clear();
_allMaps.AddRange(maps);
_total = maps.Length;
_finished = 0;
UpdateProcess();
for (var i = 0; i < threadCount; i++)
{
Threads.Add(new WorkThread(GetNexTable, Report));
}
}
public override async Task Run()
{
this.Configurations.ForEach(config =>
{
var configTask = new Task(async() =>
{
await Client.System.MonitorEventsAsync(new ContainerEventsParameters(), new Progress <JSONMessage>(
(m) =>
{
Thread.Sleep(config.Wait);
OnTriggered(config);
}));
});
Threads.Add(config, configTask);
});
Threads.Values.ForEach(t => t.Start());
Task.WaitAll(Threads.Values.ToArray());
}
