public void CheckThatLazyWorksWithMultipleThreads()
        {
            var threads = new Thread[30];
            int counter = 0;

            var lazy = LazyFactory.CreateMultithreadLazy(() => { counter++; return(42); });

            for (var i = 0; i < threads.Length; ++i)
            {
                threads[i] = new Thread(() =>
                {
                    lazy.Get();
                });
            }

            threads.ToList().ForEach(x => x.Start());
            threads.ToList().ForEach(x => x.Join());

            Assert.AreEqual(1, counter);
        }
Exemple #2
0
        static void runMultyThread(Action action, int threadCount)
        {
            Thread[] thArray = new Thread[threadCount];
            for (int i = 0; i < threadCount; i++)
            {
                thArray[i] = new Thread(new ThreadStart(action));
                thArray[i].Start();
            }

            thArray.ToList().ForEach(t => t.Join());
        }
Exemple #3
0
        static void Main(string[] args)
        {
            Console.WriteLine("**** Sync thread ****");

            var printer = new Printer();

            Thread[] threads = new Thread[10];

            for (int i = 0; i < 10; i++)
            {
                threads[i]      = new Thread(printer.PrintNumbersSafe);
                threads[i].Name = string.Format("Worker thread #{0}", i);
            }

            threads.ToList().ForEach(t => t.Start());
            Console.ReadLine();

            // a thread safe exchange
            string first  = "first";
            string second = "second";

            second = Interlocked.Exchange(ref first, second);
        }
Exemple #4
0
        public void AggregationTest()
        {
            var random = new Random(
                int.Parse(Guid.NewGuid().ToString().Replace("-", "").Substring(0, 7), NumberStyles.HexNumber)
                );

            //параметры теста
            var writeThreadCount = 10;// Environment.ProcessorCount + 2;
            var readThreadCount = 6;//Environment.ProcessorCount;// * 2;
            var itemCount = 100000;
            var maxValue = 1000;

            //подготовка данных
            var correctAccumulator = 0L;

            _datas = new Item[writeThreadCount][];
            for (var di = 0; di < writeThreadCount; di++)
            {
                _datas[di] = new Item[itemCount];

                for (var ii = 0; ii < itemCount; ii++)
                {
                    var v = random.Next(maxValue) + 1;

                    _datas[di][ii] = new Item(v);

                    //Debug.WriteLine("Generated {0}", v);

                    correctAccumulator += v;

                    _totalCount++;
                }
            }

            Debug.WriteLine("CorrectAccumulator {0}", correctAccumulator);

            var writeThreads = new Thread[writeThreadCount];
            for (var ti = 0; ti < writeThreads.Length; ti++)
            {
                var wt = new Thread(WriteThread);
                //wt.Priority = ThreadPriority.AboveNormal;

                writeThreads[ti] = wt;
            }

            var readThreads = new Thread[readThreadCount];
            for (var ti = 0; ti < readThreads.Length; ti++)
            {
                readThreads[ti] = new Thread(ReadThread);
            }

            _allThreads = writeThreads.ToList();
            _allThreads.AddRange(readThreads);

            //run the test
            for (var ti = 0; ti < writeThreads.Length; ti++)
            {
                writeThreads[ti].Start(ti);
            }
            for (var ti = 0; ti < readThreads.Length; ti++)
            {
                readThreads[ti].Start(ti);
            }

            _threadWorkEvent.Set();

            var before = DateTime.Now;

            //все заеблось!

            for (var ti = 0; ti < _allThreads.Count; ti++)
            {
                _allThreads[ti].Join();
            }

            var after = DateTime.Now;

            Item r;
            if (_itemWaitProvider.GetItem(TimeSpan.Zero, out r) == OperationResultEnum.Success)
            {
                Assert.Fail("чота недочитали!");
            }

            ((IDisposable)_itemWaitProvider).Dispose();

            Debug.WriteLine("Total count {0}, written count {1}, read count {2}", _totalCount, _writeCount, _readCount);
            Debug.WriteLine("Expected {0}, taken {1}", correctAccumulator, _accumulator);
            Debug.WriteLine("Time taken {0}", after - before);

            if (string.IsNullOrEmpty(_forceAbortReason))
            {
                Assert.AreEqual(correctAccumulator, _accumulator);
            }
            else
            {
                Debug.WriteLine("FORCE ABORT: " + _forceAbortReason);

                Assert.Fail();

            }
        }
Exemple #5
0
        public void MultiThreadConvertToParty(List <FileInfo> files, DirectoryInfo outputDir)
        {
            filesCount = files.Count;
            uint numThreads = 8;// (uint)Environment.ProcessorCount;
            uint chunk      = (uint)filesCount / numThreads;

            Thread[] threads = new Thread[numThreads];
            for (uint i = 0; i < numThreads; ++i)
            {
                uint chunkStart = i * chunk;
                uint chunkEnd   = chunkStart + chunk;
                if (i == numThreads - 1) // the latest thread should work with all rest files
                {
                    chunkEnd = (uint)filesCount;
                }

                threads[i] = new Thread(() =>
                {
                    for (uint number = chunkStart; number < chunkEnd; number++)
                    {
                        var file           = files[(int)number];
                        var outputFileName = outputDir.FullName + @"\" + ConvertFileNameToParty(file.Name) + ".txt";

                        var hands = SplitHands(File.ReadAllLines(file.FullName).Select(l => l.Trim()).ToList());

                        using (
                            StreamWriter sw =
                                new StreamWriter(new FileStream(outputFileName, FileMode.Create, FileAccess.Write, FileShare.Write)))
                        {
                            foreach (var hand in hands)
                            {
                                var handParty = hand.ToParty();
                                if (handParty != null)
                                {
                                    foreach (var line in handParty)
                                    {
                                        sw.WriteLine(line);
                                        sw.Flush();
                                    }
                                }
                            }
                        }

                        var convertedFile = new FileInfo(outputFileName);
                        if (convertedFile.Length == 0)
                        {
                            convertedFile.Delete();
                            skippedFilesCount++;
                        }
                        else
                        {
                            convertedFilesCount++;
                        }
                    }
                });
                threads[i].IsBackground = true;
                //threads[i].Start();
            }

            threads.ToList().ForEach(t => t.Start());

            while (threads.Any(t => t.IsAlive))
            {
                var percent = 100 * (skippedFilesCount + convertedFilesCount) / filesCount;
                ConvertProgressBar.Value = (int)percent;
            }
            foreach (var thread in threads)
            {
                thread.Join();
            }
        }