コード例 #1
0
        private void DecompressBlockAsynchThread(object buffersReferences)
        {
            BuffersReferences buffers                = (BuffersReferences)buffersReferences;
            Queue <DataBlock> readDataBuffer         = buffers.InputDataBuffer;
            List <DataBlock>  decompressedDataBuffer = buffers.OutputDataBuffer;

            while (decompressInProgress)
            {
                while (decompressedDataBuffer.Count >= bufferSize)//выходной буфер заполнен
                {
                    Console.WriteLine("Thread wait for space in Output buffer");
                    Thread.Sleep(100);//Ждем освобождения буфера
                }
                if (readDataBuffer.Count > 0)
                {
                    DataBlock readedBlock = new DataBlock(new byte[0], 0, 0);
                    bool      blockReaded = false;
                    lock (locker)
                    {
                        if (readDataBuffer.Count > 0)
                        {
                            readedBlock = readDataBuffer.Dequeue();
                            blockReaded = true;
                        }
                    }
                    if (blockReaded)
                    {
                        GC.Collect();
                        using (MemoryStream compressedDataStream = new MemoryStream(readedBlock.Data))
                        {
                            byte[] uncompressedData = new byte[readedBlock.DecompressedBlockSize];

                            using (GZipStream streamCompressed = new GZipStream(compressedDataStream, CompressionMode.Decompress))
                            {
                                streamCompressed.Read(uncompressedData, 0, uncompressedData.Length);
                            }

                            lock (locker)
                            {
                                decompressedDataBuffer.Add(new DataBlock(uncompressedData, readedBlock.Id));
                            }
                            uncompressedData = null;
                        }
                    }
                }
                else
                {
                    Console.WriteLine("Thread Wait for Data");
                    Thread.Sleep(100);//wait to readDataBuffer enqueue
                }
            }
        }
コード例 #2
0
        private void CompressBlockAsynchThread(object buffersReferences)
        {
            BuffersReferences buffers              = (BuffersReferences)buffersReferences;
            Queue <DataBlock> readDataBuffer       = buffers.InputDataBuffer;
            List <DataBlock>  compressedDataBuffer = buffers.OutputDataBuffer;

            while (compressInProgress)
            {
                while (compressedDataBuffer.Count >= bufferSize)//выходной буфер заполнен
                {
                    Console.WriteLine("Thread wait for space in Output buffer");
                    Thread.Sleep(1000);//Ждем освобождения буфера
                }
                if (readDataBuffer.Count > 0)
                {
                    DataBlock readedBlock = new DataBlock(new byte[0], 0);
                    bool      blockReaded = false;
                    lock (locker)
                    {
                        if (readDataBuffer.Count > 0)
                        {
                            readedBlock = readDataBuffer.Dequeue();
                            blockReaded = true;
                        }
                    }
                    if (blockReaded)
                    {
                        GC.Collect();
                        byte[] size;
                        long   blockSize;
                        using (MemoryStream compressedDataFull = new MemoryStream())
                            using (MemoryStream compressedDataStream = new MemoryStream())
                            {
                                using (GZipStream streamCompressed = new GZipStream(compressedDataStream, CompressionMode.Compress))
                                {
                                    blockSize = readedBlock.Data.Length;
                                    streamCompressed.Write(readedBlock.Data, 0, readedBlock.Data.Length);
                                }

                                byte[] compressedData = compressedDataStream.ToArray();

                                size = BitConverter.GetBytes(blockSize);//пишем размер блока файла
                                compressedDataFull.Write(size, 0, size.Length);

                                size = BitConverter.GetBytes((long)compressedData.Length);//размер сжатого блока
                                compressedDataFull.Write(size, 0, size.Length);
                                size = null;

                                compressedDataFull.Write(compressedData, 0, compressedData.Length);//сжатый блок
                                compressedData = null;

                                lock (locker)
                                {
                                    compressedDataBuffer.Add(new DataBlock(compressedDataFull.ToArray(), readedBlock.Id));
                                }
                            }
                    }
                }
                else
                {
                    Console.WriteLine("Thread Wait for Data");
                    Thread.Sleep(1000);//wait to readDataBuffer enqueue
                }
            }
        }