100多行代码实现6秒完成50万条多线程并发日志文件写入

最新推荐文章于 2022-01-24 23:27:38 发布
最新推荐文章于 2022-01-24 23:27:38 发布
阅读量186 收藏
点赞数
文章标签： 操作系统
原文链接：http://www.cnblogs.com/s0611163/p/7234361.html
版权

100多行代码实现6秒完成50万条多线程并发日志文件写入，支持日志文件分隔

日志工具类代码：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Utils
{
    /// <summary>
    /// 写日志类
    /// </summary>
    public class LogUtil
    {
        #region 字段
        public static object _lock = new object();
        public static string path = "D:\\log";
        public static int fileSize = 10 * 1024 * 1024; //日志分隔文件大小
        private static ConcurrentQueue<Tuple<string, string>> msgQueue = new ConcurrentQueue<Tuple<string, string>>();
        #endregion

        #region 静态构造函数
        static LogUtil()
        {
            Thread thread = new Thread(new ThreadStart(() =>
            {
                try
                {
                    int i;
                    List<string> list;
                    Tuple<string, string> tuple;

                    while (true)
                    {
                        i = 0;
                        list = new List<string>();
                        while (msgQueue.TryDequeue(out tuple) && i++ < 10000)
                        {
                            list.Add(tuple.Item1.PadLeft(8) + tuple.Item2);
                        }
                        if (list.Count > 0)
                        {
                            WriteFile(list, CreateLogPath());
                        }

                        Thread.Sleep(1);
                    }
                }
                catch
                {

                }
            }));
            thread.IsBackground = true;
            thread.Start();
        }
        #endregion

        #region 写文件
        /// <summary>
        /// 写文件
        /// </summary>
        public static void WriteFile(List<string> list, string path)
        {
            try
            {
                if (!Directory.Exists(Path.GetDirectoryName(path)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(path));
                }

                if (!File.Exists(path))
                {
                    using (FileStream fs = new FileStream(path, FileMode.Create)) { fs.Close(); }
                }

                using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write))
                {
                    using (StreamWriter sw = new StreamWriter(fs))
                    {
                        list.ForEach(item =>
                        {
                            #region 日志内容
                            string value = string.Format(@"{0} {1}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), item);
                            #endregion

                            sw.WriteLine(value);
                        });

                        sw.Flush();
                    }
                    fs.Close();
                }
            }
            catch { }
        }
        #endregion

        #region 生成日志文件路径
        /// <summary>
        /// 生成日志文件路径
        /// </summary>
        public static string CreateLogPath()
        {
            int index = 0;
            string logPath;
            bool bl = true;
            do
            {
                index++;
                logPath = Path.Combine(path, "Log" + DateTime.Now.ToString("yyyyMMdd") + (index == 1 ? "" : "_" + index.ToString()) + ".txt");
                if (File.Exists(logPath))
                {
                    FileInfo fileInfo = new FileInfo(logPath);
                    if (fileInfo.Length < fileSize)
                    {
                        bl = false;
                    }
                }
                else
                {
                    bl = false;
                }
            } while (bl);

            return logPath;
        }
        #endregion

        #region 写错误日志
        /// <summary>
        /// 写错误日志
        /// </summary>
        public static void LogError(string log)
        {
            msgQueue.Enqueue(new Tuple<string, string>("[Error] ", log));
        }
        #endregion

        #region 写操作日志
        /// <summary>
        /// 写操作日志
        /// </summary>
        public static void Log(string log)
        {
            msgQueue.Enqueue(new Tuple<string, string>("[Info]  ", log));
        }
        #endregion

    }
}
View Code

使用条件变量模式改进：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Utils
{
    /// <summary>
    /// 写日志类
    /// </summary>
    public class LogUtil
    {
        #region 字段
        public static object _lock = new object();
        public static string path = "D:\\log";
        public static int fileSize = 10 * 1024 * 1024; //日志分隔文件大小
        private static ConcurrentQueue<Tuple<string, string>> msgQueue = new ConcurrentQueue<Tuple<string, string>>();
        #endregion

        #region 静态构造函数
        static LogUtil()
        {
            Thread thread = new Thread(new ThreadStart(() =>
            {
                try
                {
                    Monitor.Enter(_lock);
                    int i;
                    List<string> list;
                    Tuple<string, string> tuple;

                    while (true)
                    {
                        Monitor.Wait(_lock);

                        i = 0;
                        list = new List<string>();
                        while (msgQueue.TryDequeue(out tuple) && i++ < 10000)
                        {
                            list.Add(tuple.Item1.PadLeft(8) + tuple.Item2);
                        }
                        if (list.Count > 0)
                        {
                            WriteFile(list, CreateLogPath());
                        }
                    }
                }
                catch
                {

                }
            }));
            thread.IsBackground = true;
            thread.Start();
        }
        #endregion

        #region 写文件
        /// <summary>
        /// 写文件
        /// </summary>
        public static void WriteFile(List<string> list, string path)
        {
            try
            {
                if (!Directory.Exists(Path.GetDirectoryName(path)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(path));
                }

                if (!File.Exists(path))
                {
                    using (FileStream fs = new FileStream(path, FileMode.Create)) { fs.Close(); }
                }

                using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write))
                {
                    using (StreamWriter sw = new StreamWriter(fs))
                    {
                        list.ForEach(item =>
                        {
                            #region 日志内容
                            string value = string.Format(@"{0} {1}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), item);
                            #endregion

                            sw.WriteLine(value);
                        });

                        sw.Flush();
                    }
                    fs.Close();
                }
            }
            catch { }
        }
        #endregion

        #region 生成日志文件路径
        /// <summary>
        /// 生成日志文件路径
        /// </summary>
        public static string CreateLogPath()
        {
            int index = 0;
            string logPath;
            bool bl = true;
            do
            {
                index++;
                logPath = Path.Combine(path, "Log" + DateTime.Now.ToString("yyyyMMdd") + (index == 1 ? "" : "_" + index.ToString()) + ".txt");
                if (File.Exists(logPath))
                {
                    FileInfo fileInfo = new FileInfo(logPath);
                    if (fileInfo.Length < fileSize)
                    {
                        bl = false;
                    }
                }
                else
                {
                    bl = false;
                }
            } while (bl);

            return logPath;
        }
        #endregion

        #region 写错误日志
        /// <summary>
        /// 写错误日志
        /// </summary>
        public static void LogError(string log)
        {
            msgQueue.Enqueue(new Tuple<string, string>("[Error] ", log));
            Task.Factory.StartNew(() =>
            {
                Monitor.Enter(_lock);
                Monitor.PulseAll(_lock);
                Monitor.Exit(_lock);
            });
        }
        #endregion

        #region 写操作日志
        /// <summary>
        /// 写操作日志
        /// </summary>
        public static void Log(string log)
        {
            msgQueue.Enqueue(new Tuple<string, string>("[Info]  ", log));
            Task.Factory.StartNew(() =>
            {
                Monitor.Enter(_lock);
                Monitor.PulseAll(_lock);
                Monitor.Exit(_lock);
            });
        }
        #endregion

    }
}
View Code

测试代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Utils;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            LogUtil.path = Application.StartupPath + "\\log"; //初始化日志路径
        }

        private void button1_Click(object sender, EventArgs e)
        {
            for (int n = 0; n < 10; n++)
            {
                Thread thread = new Thread(new ThreadStart(() =>
                {
                    int i = 0;
                    for (int k = 0; k < 50000; k++)
                    {
                        LogUtil.Log((i++).ToString() + "    abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcda3.1415bcdabcdabcdabcdabc@#$%^&dabcdabcdabcdabcdabcdabcdabcdabcd");
                    }
                }));
                thread.IsBackground = true;
                thread.Start();
            }
        }
    }
}
View Code

 测试截图：

 

转载于:https://www.cnblogs.com/s0611163/p/7234361.html

weixin_34032827
关注
python实现多线程并发测试并生成excel报告
LYX_WIN
12-02 1145
同时，也可以借助第三方的并发测试工具和框架，如JMeter、Locust等，来简化并发测试的实现和管理。在大规模并发和极端情况下，系统的行为可能会出现意料之外的问题，这些问题可能无法通过常规的多线程并发测试发现。使用with语句管理资源：对于需要显式关闭的资源（例如文件、网络连接等），可以使用Python的with语句来管理资源，确保资源在使用完毕后能够被正确关闭，避免出现异常情况。根据系统的资源限制和测试需求，可以逐步增加并发数量和线程数量，观察系统的负载情况，确保在承受范围内进行测试。
【Java多线程】并发编程不得不知的重要概念(持续更新)
墩墩分墩
07-24 743
1. 串行：一个线程执行到底，相当于单线程。 2. 并发：多个线程交替执行，抢占cpu的时间片，但是速度很快，在外人看来就像是多个线程同时执行。 3. 并行：多个线程在不同的cpu中同时执行。
写日志DLL(高并发)
03-02
{*******************************************************} { } { eLoner } { } { 版权所有 (C) 2011 五两软件 } { } {*******************************************************} 适用于普通程序、高并发程序、服务程序的日志记录。 1.采用多线程技术进行对日志的记录。 2.在写日志过程中还可以正常使用正在记录的日志文件。 3.在产生日志的同时将一些重要的日志直接在DebugView中显示。（只要打开DebugView软件即可） 4.日志保存的路径一旦不存在，自动会在程序当前目录下产生日志文件。 5.为了保证日志的统一性记录，方便查询，采用单个多线程。 //使用方法 //1.创建日志，跟随你的程序同步创建。 //2.存放日志，需要写日志时就调用该函数。 //3.销毁日志，跟随你的程序同步销毁。 //注意：在销毁日志的同时，还没有写完的日志会移交给后台处理，完成后自动销毁。 程序运行过程中有问题，随时欢迎大家提意见和需求，不断的完善。 eLoner QQ:907230179
3秒钟完成50万条并发日志 文件写入
weixin_30337157的博客
03-23 620
前言 目前本人从事 JAVA开发 之前讲过《你的日志组件记录够清晰嘛？--自己开发日志组件 Logger》日志文件，当你是羡慕java下面的log4j，打印日志够清晰，可以很清晰定位打印日志所在文件，行号等； 于是尝试了重写了日志组件来模拟清晰打印； 序言 最近和群里大佬们研究游戏服务器架构的时候，讨论像魔兽，完美国际等游戏世界场景无缝地图实现方案；讨论两周后开始动手BB自己的服务器...
muduo网络库：17---高效的多线程日志之（多线程异步日志、其他方案）
董哥的黑板报
03-25 1516
本文内容衔接于前一篇文章（日志概述、功能需求、性能需求）：https://blog.csdn.net/qq_41453285/article/details/105091022 一、多线程中的日志安全 多线程程序对日志库提出了新的需求：线程安全。即多个线程可以并发写日志，两个线程的日志消息不会出现交织 线程安全不难办到， 简单的办法是： 用一个全局mutex保护IO 或者每个线程单独写一...
易语言客户源码,易语言服务器源码,易语言多线程传送大字节集数据
08-20
易语言多线程传送大字节集数据系统结构:字节集_付值, ======窗口程序集1 || ||------_按钮1_被单击 || ||------__启动窗口_创建完毕 || ||------字节集_付值 ======窗口程序集1 || ||------_服务器1_数
要从Java往数据库某个表中插入100万行数据，要求速度尽量快，方案和优化思路？
stackCSDN的博客
05-04 8994
1.利用mybatis的foreach拼接动态aql或者在java中写循环拼接，将数据分组拼接成大sql,比如可以每1万行数据拼接为一个insert语句，只要连接1000次数据库即可。2.设置mybatis的sqlsession的ExecutorType为batch,如果用Jdbc则用executeBatch.3.去掉表中的非主键索引。4.取消该表自动提交。5.利用多线程异步执行，但每个线程需要加...
python3多线程写入mysql_Python3 多线程(连接池)操作MySQL插入数据
weixin_31094177的博客
02-11 794
1.主要模块DBUtils : 允许在多线程应用和数据库之间连接的模块套件Threading : 提供多线程功能2.创建连接池PooledDB 基本参数：mincached : 最少的空闲连接数，如果空闲连接数小于这个数，Pool自动创建新连接;maxcached : 最大的空闲连接数，如果空闲连接数大于这个数，Pool则关闭空闲连接;maxconnections : 最大的连接数;blockin...
Golang并发读取文件数据并写入数据库
Monkey_D_Newdun的博客
01-24 5095
记录一下用Golang做并发，创建多个goroutine去读取指定目录下的多个JSON格式的数据文件，并将其每条数据格式化后写入到Oracle数据库
多线程并发同步千万数据
weixin_44320593的博客
11-25 2225
一、背景 对于java开发中，十万百万千万级别的list进行各种操作，然后入库等操作好多时候会遇到。普通单线程处理，处理时间长，还经常报gc问题。针对此问题，查阅了网上很多资料，好多都使用多线程来处理。跟着好多的博客进行处理，要么是线程安全问题，要么根本速度就提高不了。我针对我项目中的使用场景，结合资料进行了修改，特提交此文，为有共同需求的小伙伴提供一点建议。 ———————————————— 开发过程中，合理地使用线程池可以带来3个好处： 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗
java 多线程 写日志_Java 线程中记录日志
weixin_34255327的博客
02-24 1091
import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.PrintWriter;import java.util.HashMap;public class ThreadLog{private final static String _detailLogFile = "...
多线程写入日志读写锁
我的博客
05-17 1159
多线程写入日志 读写锁 ReaderWriterLock 、就是支持单个写线程和多个读线程的锁。自.NET 3.5 开始 ReaderWriterLockSlim登上舞台，ReaderWriterLockSlim 可以看做是 ReaderWriterLock 的升级版。 由于 ReaderWriterLockSlim 默认不支持递归调用、所以在某种意义上来说更不容易造成死锁。 ReaderWrit...
springboot多线程读取百万级数据写入文件
殇之何伤的博客
08-08 5036
1、springboot 配置线程池 package com.toycloud.awaken.platform.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync; import org.spr
第5章高效的多线程日志
qq_36553387的博客
09-02 2399
文章目录高效的多线程日志5.1 功能需求5.3 多线程异步日志关键代码 高效的多线程日志 “日志”主要指 诊断日志：常用日志库提供的日志功能。 交易日志：用于记录状态变更，通过回放日志可以逐步恢复每一次修改之后的状态。 对于关键进程，日志通常需要记录： 收到的每条内部消息的id； 收到的每条外部信息的全文； 发出的每条消息的全文，每条消息都有全局唯一的id； 关键内部状态的变更； 一个日志库可以分为前端和后端两部分。前端是供应用程序使用的接口（API），并生成日志消息；后端负责把日志消息写到目的地。
多线程实现百万级数据快速写入数据库
小小程序
05-15 7297
参考文章：Java-快速读取百万级数据文件，插入数据库 最近面试被问到如何快速将百万级数据保存到数据库。当时回答不理想，事后总结如下。 主要思路： 1.首先将数据一次读入到内存（如果文件超过系统内存，会有问题。具体解决方案我没尝试）； 2.开辟多个线程，每个线程新建一个数据库连接； 3.每个线程批量执行插入操作。必须要设置conn.setAutoCommit(false)。这个很重。 具体实现步骤如下： 1. 获取jdbc连接类 package io; import java.sql.C
10台机器，每台4核，1000并发如何设计？
Java后端技术
09-24 1145
当我刷到这条脉脉的时候，想到当年老板面试我的时候，拿多线程问题虐我时，想想当时太难了。悄悄给大家看几道阿里必问的面试题，测测能完美的回答几道呢？有没有一种一定能保证线程安全的代码写法？（...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值