public static async Task <ModelWrapper> PullModel()
{
if (!modelPool.TryDequeue(out var model))
{
ConnectionWrapper conn = null;
foreach (var item in connectionList)
{
if (item.Increment() <= 10)
{
conn = item;
break;
}
else
{
item.Decrement();
}
}
if (conn == null && Interlocked.Increment(ref connectionCount) <= rabbitHost.MaxPoolSize)
{
conn = new ConnectionWrapper()
{
Connection = _Factory.CreateConnection(rabbitHost.EndPoints)
};
conn.Connection.ConnectionShutdown += (obj, args) =>
{
conn.Connection = _Factory.CreateConnection(rabbitHost.EndPoints);
conn.Reset();
};
connectionList.Add(conn);
}
if (conn != null)
{
model = new ModelWrapper()
{
Model = conn.Connection.CreateModel()
};
model.Model.ConfirmSelect();
}
else
{
Interlocked.Decrement(ref connectionCount);
}
}
if (model == null)
{
var taskSource = new TaskCompletionSource <ModelWrapper>();
modelTaskPool.Enqueue(taskSource);
var cancelSource = new CancellationTokenSource(3000);
cancelSource.Token.Register(() =>
{
taskSource.SetException(new Exception("获取rabbitmq的model超时"));
});
model = await taskSource.Task;
}
if (model.Model.IsClosed)
{
model = await PullModel();
}
return(model);
}
public ModelWrapper(ConnectionWrapper connectionWrapper, IModel model)
{
Connection = connectionWrapper;
Model = model;
persistentProperties = this.Model.CreateBasicProperties();
persistentProperties.Persistent = true;
noPersistentProperties = this.Model.CreateBasicProperties();
noPersistentProperties.Persistent = false;
}
public async ValueTask <ModelWrapper> PullModel()
{
ConnectionWrapper GetConnection()
{
var fullList = new List <ConnectionWrapper>();
while (connectionQueue.TryDequeue(out var connectionWrapper))
{
if (connectionWrapper.Connection.IsOpen)
{
if (connectionWrapper.Increment() <= 16)
{
connectionQueue.Enqueue(connectionWrapper);
return(connectionWrapper);
}
else
{
connectionWrapper.Decrement();
fullList.Add(connectionWrapper);
}
}
}
foreach (var item in fullList)
{
connectionQueue.Enqueue(item);
}
return(null);
}
if (!modelPool.TryDequeue(out var model))
{
var conn = GetConnection();
if (conn == null && Interlocked.Increment(ref connectionCount) <= rabbitHost.MaxPoolSize)
{
Task.Run(() =>
{
conn = new ConnectionWrapper
{
Client = this,
Connection = _Factory.CreateConnection(rabbitHost.EndPoints)
};
conn.Increment();
connectionQueue.Enqueue(conn);
}).GetAwaiter().GetResult();
}
else
{
Interlocked.Decrement(ref connectionCount);
}
if (conn != null)
{
model = new ModelWrapper(conn, conn.Connection.CreateModel());
model.Model.ConfirmSelect();
modelList.Add(model);
}
}
if (model == null)
{
var taskSource = new TaskCompletionSource <ModelWrapper>();
modelTaskPool.Enqueue(taskSource);
var cancelSource = new CancellationTokenSource(3000);
cancelSource.Token.Register(() =>
{
taskSource.SetException(new Exception("get rabbitmq's model timeout"));
});
model = await taskSource.Task;
}
return(model);
}
