public IProducerConsumerPattern ProducerConsumer <T>(Func <T> producerFunc, byte producerCount, Action <T> consumerAction, byte consumerCount) { IConcurrentQueue <T> queue = new SynchronizedQueue <T>(); IProducerConsumerPattern pattern = new ProducerConsumerPattern <T>(this, queue, producerFunc, producerCount, consumerAction, consumerCount); return(pattern); }
public Byte[] Decompress() { var zipOperation = new ZipDecompressor(); var readerQueue = new SynchronizedQueue <Chunk>(4); var writerQueue = new SynchronizedQueue <Chunk>(4); zipOperation.Cancel += readerQueue.Close; zipOperation.Cancel += writerQueue.Close; var reader = new Thread(() => zipOperation.Reader(MID_OUTPUT_FILE, ref readerQueue)); var proces = new Thread(() => zipOperation.Process(ref readerQueue, ref writerQueue)); var writer = new Thread(() => zipOperation.Writer(OUTPUT_FILE, ref writerQueue)); reader.Start(); proces.Start(); writer.Start(); reader.Join(); proces.Join(); writer.Join(); zipOperation.Cancel -= readerQueue.Close; zipOperation.Cancel -= writerQueue.Close; return(File.ReadAllBytes("test_input_res.txt")); }
public VirtualCashBox(ManualCashBox cashBox) { responseQueue = new SynchronizedQueue <Packet>(); device = cashBox; commandCounter = 0; }
public SberBank(SberBankMode mode) { this.mode = mode; runErrors = false; failedExtensions = new List <string>(); events = new Dictionary <Type, Delegate>(); device = new BankingDevice((byte)(Settings.Default.CashBoxID & 0xFF)); device.Message += (s, e) => { logger.Write(e ? LogLevel.Error : LogLevel.Verbose, s); }; device.StateChanged += (s, i) => { logger.Write(LogLevel.Debug, String.Format("{0}\r\n{1}", s, i)); }; device.TransactionCompleted += OnTransactionCompleted; receivedPacket = null; networkEvent = new ManualResetEvent(false); networkProtocol = null; networkThread = new ThreadHost(NetworkThread, false, true, true); networkThread.Name = "Network Dispatcher"; queue = new SynchronizedQueue <Packet>(); logger = null; pathManager = null; monitorObjects = new List <IMonitoringObject>(); startupProgress = null; extensionsFiltered = 0; }
/// <summary> /// Initializes a new instance of the <see cref="DVRPTRio"/> class. /// </summary> /// <param name="stream">Stream.</param> /// <param name="streamOwner">If set to <c>true</c> this instance is the stream owner. The stream will disposed when this instance is disposed</param> /// <param name="syncContext">When specified the PacketReceived event is fired on this context. Otherwise it is fired on a worker thread</para> protected DVRPTRio(Stream stream, bool streamOwner, SynchronizationContext syncContext) { if (stream == null) { throw new ArgumentNullException("stream"); } if (!stream.CanWrite) { throw new ArgumentException("stream is not writable"); } if (!stream.CanRead) { throw new ArgumentException("stream is not readable"); } _run = false; _disposed = false; _modemStreamReader = new BinaryReader(stream); _readModemThread = null; _readModemQueue = new SynchronizedQueue <byte[]>(); _modemStreamWriter = new BinaryWriter(stream); _writeModemThread = null; _writeModemQueue = new SynchronizedQueue <byte[]>(); _streamOwner = streamOwner; _syncContext = syncContext; }
public static void Main(string[] args) { Console.WriteLine("Hello, world!"); // This using block defines the lifetime of the queue and therefore the lifetime of all producers and consumers using (SynchronizedQueue<string> qs = new SynchronizedQueue<string>(true)) { // Now we're creating several producers and consumers AbstractQueueProducer<string> producer1 = new DummyProducer(qs); AbstractQueueProducer<string> producer2 = new DummyProducer(qs); AbstractQueueProducer<string> producer3 = new DummyProducer(qs); AbstractQueueProducer<string> producer4 = new DummyProducer(qs); AbstractQueueConsumer<string> consumer1 = new DummyConsumer(qs); AbstractQueueConsumer<string> consumer2 = new DummyConsumer(qs); AbstractQueueConsumer<string> consumer3 = new DummyConsumer(qs); AbstractQueueConsumer<string> consumer4 = new DummyConsumer(qs); AbstractQueueConsumer<string> consumer5 = new DummyConsumer(qs); // All consumers/producers have been created. Now let's have the main thread rest for a while. Thread.Sleep(5000); // Alright, enough sleeping for the main thread! Let's get out of this using block and therefore kill all consumers/workers and the queue itself! } Console.WriteLine("Goodbye, world! (press enter)"); Console.Read(); }
public void Compress(Byte[] b) { File.WriteAllBytes(INPUT_FILE, b); var zipOperation = new ZipCompressor(); var readerQueue = new SynchronizedQueue <Chunk>(4); var writerQueue = new SynchronizedQueue <Chunk>(4); zipOperation.Cancel += readerQueue.Close; zipOperation.Cancel += writerQueue.Close; var reader = new Thread(() => zipOperation.Reader(INPUT_FILE, ref readerQueue)); var proces = new Thread(() => zipOperation.Process(ref readerQueue, ref writerQueue)); var writer = new Thread(() => zipOperation.Writer(MID_OUTPUT_FILE, ref writerQueue)); reader.Start(); proces.Start(); writer.Start(); reader.Join(); proces.Join(); writer.Join(); zipOperation.Cancel -= readerQueue.Close; zipOperation.Cancel -= writerQueue.Close; }
/// <summary> /// Initializes the members of the Scheduler class and starts the execution timer. /// </summary> static Scheduler() { SchedulingSectionHandler config = (SchedulingSectionHandler) ConfigurationManager.GetSection("sharpCore/scheduling"); jobs = config.Jobs; interval = config.Interval; queue = new SynchronizedQueue<JobBase>(); }
public BarPersistence(IFelixHttpClient client) { Queue = new SynchronizedQueue(); LoaderThread = new Thread(Loader); Client = client; DoneEvent = new ManualResetEvent(false); }
internal static void Init() { lock (lockObject) { // Crittercism.Init calling APM.Init should effectively make // lock lockObject here pointless, but no real harm doing so. SettingsChange(); Filters = new HashSet <CRFilter>(); EndpointsQueue = new SynchronizedQueue <Endpoint>(new Queue <Endpoint>()); } }
public TimeComeRule(IConnector connector, IEnumerable <DateTimeOffset> times) : base(connector) { if (times == null) { throw new ArgumentNullException(nameof(times)); } var currentTime = connector.CurrentTime; var intervals = new SynchronizedQueue <TimeSpan>(); var timesList = new SynchronizedList <DateTimeOffset>(); foreach (var time in times) { var interval = time - currentTime; if (interval <= TimeSpan.Zero) { continue; } intervals.Enqueue(interval); currentTime = time; timesList.Add(time); } // все даты устарели if (timesList.IsEmpty()) { return; } Name = LocalizedStrings.Str1055; var index = 0; _timer = new MarketTimer(connector, () => { var activateTime = timesList[index++]; Activate(activateTime); if (index == timesList.Count) { _timer.Stop(); } else { _timer.Interval(intervals.Dequeue()); } }) .Interval(intervals.Dequeue()) .Start(); }
internal ChunkingReader(Message startMessage, int maxBufferedChunks, TimeoutHelper receiveTimeout) { //set innerReader this.innerReader = startMessage.GetReaderAtBodyContents(); this.lockobject = new object(); this.messageId = ChunkingUtils.GetMessageHeader <Guid>(startMessage, ChunkingUtils.MessageIdHeader, ChunkingUtils.ChunkNs); this.bufferedChunks = new SynchronizedQueue <Message>(maxBufferedChunks); this.receiveTimeout = receiveTimeout; this.nextChunkNum = 1; }
internal ChunkingReader(Message startMessage, int maxBufferedChunks, TimeoutHelper receiveTimeout) { //set innerReader this.innerReader = startMessage.GetReaderAtBodyContents(); this.lockobject = new object(); this.messageId = ChunkingUtils.GetMessageHeader<Guid>(startMessage, ChunkingUtils.MessageIdHeader, ChunkingUtils.ChunkNs); this.bufferedChunks = new SynchronizedQueue<Message>(maxBufferedChunks); this.receiveTimeout = receiveTimeout; this.nextChunkNum = 1; }
/// <summary> /// The setup is called before any actions are executed. /// It will never be called from the device file editor, but only from the experiment runner. /// </summary> public override void Setup() { // create and setup the XY Table //xyTableModule = new Communication_RS232(); //xyTableModule.Open(Config.xyTableComport.PortName, Config.xyTableComport.BaudRate); // create and setup the Microscope //MicroscopeModule = new Communication_RS232(); //MicroscopeModule.Open(Config.MicroscopeComport.PortName, Config.MicroscopeComport.BaudRate); //MicroscopeModule.PortRecievedMessageEvent += new PortRecievedMessageEventHandler(MessageRecievedEvent); // create a queue to handle the temperature data of the incubator IncubatorResultQueue = new SynchronizedQueue <IncubatorResult>(); }
/* * Constructor - Makes stream with no filter by default * and no IPC message queue * * To use with a message queue for IPC, call SetUseQueue(true) * */ public TwitterStream(string user, string pass, bool isEncrypted) { if (isEncrypted) { password = Common.Decrypt (pass); } else { password = pass; } username = user; password = pass; jsonQueue = new SynchronizedQueue<string> (); SetFiltered(false); }
static void RunJob(IEnumerator job, SynchronizedQueue <IEnumerator> queue) { try { while (job.MoveNext()) { if (job.Current == null) { break; } else if (job.Current == JobYields.SwitchToMain && queue != _MainThreadQueue) { EnqueueJob(job, _MainThreadQueue); break; } else if (job.Current == JobYields.SwitchToWorker && queue == _MainThreadQueue) { EnqueueJobOnMostFree(job); break; } else if (job.Current == JobYields.Yield) { EnqueueJob(job, queue); break; } else if (job.Current is JobYields.BaseJobYield) { var yield = job.Current as JobYields.BaseJobYield; if (yield.ShouldYield()) { var obj = new SleepingJob(); obj.yieldFunc = yield; obj.job = job; _SleepingJobs.Enqueue(obj); break; } } } } catch (System.Exception ex) { Debug.LogError(ex); Debug.Break(); } }
public BonePosePreCalculator(BonePoseCalculatorWorker worker, MmdPose pose, Poser poser, BulletPyhsicsReactor physicsReactor, float stepLength, float startTimePos, int frameCacheSize, bool autoStepLength) { _poseMode = true; _poser = poser; _physicsReactor = physicsReactor; _stepLength = stepLength; _bonePoseImagesStore = new SynchronizedQueue <BonePoseFrame>(); _timePos = startTimePos; _autoStepLength = autoStepLength; _frameCacheSize = frameCacheSize; poser.ResetPosing(); SetPoseToPoser(pose, _poser); _poser.PrePhysicsPosing(); _physicsReactor.Reset(); _poser.PostPhysicsPosing(); var image = GetBonePoseImage(_poser); _bonePoseImagesStore.Enqueue(new BonePoseFrame(startTimePos, image)); _worker = worker; }
public void TestQueueDequeue() { // ReSharper disable once ConvertToConstant.Local int numberOfObjectsToEnqueue = 100; SynchronizedQueue <object> queue = new SynchronizedQueue <object>(); //This will produce data into the queue ThreadStart producerProc = () => { Thread.Sleep(300); for (int i = 0; i < numberOfObjectsToEnqueue; i++) { queue.Enqueue(new Object()); Thread.Sleep(100); } }; Thread producer = new Thread(producerProc); producer.Start(); //this one (the main thread) will consume the data inside the main thread of the unittest object item; int itemcount = 0; do { item = queue.Dequeue(1000); itemcount++; Console.WriteLine("Dequeued {0} items", itemcount); }while(item != null); Assert.AreEqual(numberOfObjectsToEnqueue + 1, itemcount, "Dequeued count mismatch"); Assert.IsNull(item, "Last dequeued item should be null"); Assert.AreEqual(0, queue.Count, "Queue should be empty"); }
protected NetworkStatistics() { this.m_consumerTimer = new TimerEntry(new Action <int>(this.ConsumerCallback)); this.m_queuedStats = new SynchronizedQueue <PacketInfo>(); }
public static void EnqueueJob(IEnumerator coroutine, SynchronizedQueue <IEnumerator> list) { list.Enqueue(coroutine); work_cvar.Set(); }
public SynchronizedQueue(SynchronizedQueue <T> queue) { m_Queue = new Queue <T>(queue.m_Queue); m_lock = new object(); }
public abstract void Reader(string source, ref SynchronizedQueue <T> readerQueue);
public abstract void Process(ref SynchronizedQueue <T> readerTaskPool, ref SynchronizedQueue <T> writerQueue);
protected NetworkStatistics() { m_consumerTimer = new TimerEntry(ConsumerCallback); m_queuedStats = new SynchronizedQueue <PacketInfo>(); }
private void Initialize(IPEndPoint endPoint) { listener = new TcpListener(endPoint); clientQueue = new SynchronizedQueue<TcpClient>(); listenThread = new Thread(new ThreadStart(Listen)); listenThread.IsBackground = true; listenThread.Start(); }
public void TestSynchronizedQueue() { SynchronizedQueue<string> queue = new SynchronizedQueue<string>(); queue.Enqueue("one"); queue.Enqueue("two"); Assert.IsTrue(queue.Count == 2); foreach (string name in queue) { Assert.IsTrue(queue.Contains(name)); } if (queue.Peek() == "one") { queue.Dequeue(); queue.Enqueue("one"); } Assert.IsTrue(queue.Count == 2); Assert.IsTrue(queue.Peek() == "two"); queue.Clear(); Assert.IsTrue(queue.Count == 0); }
public CommandQueueMonitoringObject(SynchronizedQueue <Packet> queue) : base("Очередь команд", (int)MonitoringObjectCategory.Commands) { _queue = queue; Refresh(); }
protected NetworkStatistics() { m_consumerTimer = new TimerEntry(0f, 0f, ConsumerCallback); m_queuedStats = new SynchronizedQueue<PacketInfo>(); }
static void Main(string[] args) { ParseArgs options; Result result = new Result(); try { options = new ParseArgs(args); } catch (Exception e) { result.Error(); Console.WriteLine(e.Message); return; } if (options.Command == Operation.Compress) { ZipOperation = new ZipCompressor(); } else { ZipOperation = new ZipDecompressor(); } _readerQueue = new SynchronizedQueue <Chunk>(_cores); _writerQueue = new SynchronizedQueue <Chunk>(_cores); ZipOperation.Cancel += _readerQueue.Close; ZipOperation.Cancel += _writerQueue.Close; ZipOperation.Error += result.Error; _reader = new Thread(() => ZipOperation.Reader(options.Source, ref _readerQueue)); for (int i = 0; i < _cores; i++) { _process[i] = new Thread(() => ZipOperation.Process(ref _readerQueue, ref _writerQueue)); } _writer = new Thread(() => ZipOperation.Writer(options.Sink, ref _writerQueue)); _reader.Start(); foreach (Thread proces in _process) { proces.Start(); } _writer.Start(); _reader.Join(); foreach (Thread proces in _process) { proces.Join(); } _writer.Join(); result.Ok(); ZipOperation.Cancel -= _writerQueue.Close; ZipOperation.Cancel -= _readerQueue.Close; ZipOperation.Error -= result.Error; }
public abstract void Writer(string sink, ref SynchronizedQueue <T> writerQueue);