泛型队列

Posted 2023-04-17 归来是少年

#队列就是先进先出，后进后出，相当于排队，排的人只能再末尾追加，但是出去的人是从队首先出
package main

import "fmt"

type Queue[T string | int] struct 
	data []T 


//追加方法
func (q *Queue[T]) Put(value T) []T 
	q.data = append(q.data, value)
	return q.data



//移除方法
func (q *Queue[T]) Pop() []T 
	if len(q.data) > 0 
		q.data = q.data[1:]
		return q.data
	
	return nil


func main() 
	q1 := Queue[string][]string"张三", "李四"
	q1.Put("王五")
	q1.Put("韩梅梅")
	fmt.Println(q1.data)
	q1.Pop()
	fmt.Println(q1.data)
	q1.Pop()
	q1.Pop()
	q1.Pop()
	q1.Pop()
	fmt.Println(q1.data)

基于多线程任务队列执行时间测试——泛型单例模式落地

目录

• 基于多线程任务队列执行时间测试——泛型单例模式落地
• 1.需求
• 2.遇到的问题
• 3.解决思路
• 4.具体代码
  • 4.1泛型单例
  • 4.2 开始时间实体
  • 4.3 实例化单例
  • 4.4 获取任务结束时间
• 5.小结
  • 5.1 本文提供了单例模式实际应用中的一次落地；
  • 5.2 单例模式适用于全局不变的实例；
  • 5.3 泛型实现单例，适用于不同的数据类型实例；
  • 5.4 单例可以跨线程，内存级别共享。

基于多线程任务队列执行时间测试——泛型单例模式落地

1.需求

比如有100个任务，多线程异步执行，统计执行完所有任务所耗费的时间。如，开始线程是线程A，最后的线程是B，记录B的DataTime.Now-A的DataTime.Now.

2.遇到的问题

因为这里涉及到多线程，异步，所以需要在最后一个任务线程判断是否执行完。跟任务开始的线程肯定不属于同一个线程。相当于要在不同线程里记录传递变量。

3.解决思路

需要有个全局的单例来记录A开始的DateTime.Now。然后在B中取当前时间减去A的开始时间，即为面向内存级别的任务队列的执行时间。

4.具体代码

4.1泛型单例

因为开始时间是DataTime类型，而且考虑到以后单例会用到各种类型，所以这里用泛型去实现。

namespace Singleton
{
    /**//// <summary>
       /// 泛型实现单例模式
       /// </summary>
       /// <typeparam name="T">需要实现单例的类</typeparam>
    public class Singleton<T> where T : new()
    {
        /**//// <summary>
           /// 返回类的实例
           /// </summary>
        public static T Instance
        {
            get { return SingletonCreator.instance; }
        }

        class SingletonCreator
        {
            internal static readonly T instance = new T();
        }
    }
}?

4.2 开始时间实体

startTime.cs

     public class StartTime
    {
        private DateTime _time;
        public StartTime()
        {
            _time = DateTime.Now;
        }

        public string Time
        {
            get { return _time.ToString(); }
        }
    }

4.3 实例化单例

在主线程中，调用6W个任务之前实例化单例。

            var _startTime = Singleton<StartTime>.Instance.Time;
            Console.WriteLine("开始时间 " + _startTime );
            for (int i=0;i<=60000;i++){
                int Wait=rnd.Next(1,10) * 1000;
                var parm=new MyParameters{delayTime= 2000, JobNo=i};

                obj.Queue(futureTask: async ()=>{await RunMyJob(parm);  });
            }

4.4 获取任务结束时间

最后一个任务结束时，获取当前时间，再减去单例的任务开始时间即可。

            if (_processingQueue.IsEmpty && _runningTasks.IsEmpty)
            {
                // Interlocked.Exchange might not be necessary
                var _oldQueue = Interlocked.Exchange(
                    ref _tscQueue, new TaskCompletionSource<bool>());
                _oldQueue.TrySetResult(true);

                _isQueueRunning = false;
                var TaskTime = DateTime.Now - Convert.ToDateTime(Singleton<StartTime>.Instance.Time);
                Console.WriteLine("任务所用时间 " + TaskTime);
            }

5.小结

5.1 本文提供了单例模式实际应用中的一次落地；

5.2 单例模式适用于全局不变的实例；

5.3 泛型实现单例，适用于不同的数据类型实例；

5.4 单例可以跨线程，内存级别共享。