/// <summary> /// 配置队列线程 /// </summary> private void ConfigQueueThread() { String appName = m_ConsumerConfig.ApplicationName; if (m_EsbConfig.ServiceConfig != null && m_EsbConfig.ServiceConfig.Count > 0) { //--根据QueueCenter的消费者配置文件中的ApplicationName找到和本机相关的配置文件 List <EsbView_ServiceConfig> lstServcieConfig = m_EsbConfig.ServiceConfig.FindAll(x => { return(!String.IsNullOrEmpty(x.QueueCenterUri) && appName.EndsWith(x.QueueCenterUri)); }); //--删除不应该由本机消费的队列并停用相关线程 DeleteQueueThread(lstServcieConfig); //--添加本机应该消费的队列 foreach (EsbView_ServiceConfig sc in lstServcieConfig) { if (!m_QueueThreadDict.ContainsKey(sc.ServiceName)) { RabbitMQClient rabbitMQ = new RabbitMQClient(m_ParamMQ[0], m_ParamMQ[2], m_ParamMQ[3], Int32.Parse(m_ParamMQ[1])); QueueThread qt = new QueueThread(sc.ServiceName, rabbitMQ); qt.Start(); m_QueueThreadDict[sc.ServiceName] = qt; } } } else { //--删除不应该由本机消费的队列并停用相关线程 DeleteQueueThread(null); } }
protected void InitRabbitClient() { client = new RabbitMQClient("iClock Service Queue"); client.OnRecieved += (model, message) => { if (fingerPrinterManager != null && !string.IsNullOrEmpty(message)) { try { CommandObject command = client.JsonDeserialize(message); switch (command.Command) { case MessageCommandEnum.DISCONNECT: { string ip = command.Data as string; fingerPrinterManager.Disconnect(ip); break; } case MessageCommandEnum.CONNECT: { string ip = command.Data as string; fingerPrinterManager.Connect(ip); break; } } } catch (Exception ex) { logger.Error(ex.Message, ex); } } }; }
public IActionResult SendRegistration([FromBody] Register command) { try { var registration = new Register(); using (var session = Store.LightweightSession()) { registration.Name = command.Name; registration.Address = command.Address; registration.City = command.City; registration.Email = command.Email; session.Insert(registration); session.SaveChanges(); } RabbitMQClient client = new RabbitMQClient(); client.SendRegistration(registration); client.Close(); return(Ok(registration)); } catch (Exception) { return(BadRequest()); } }
/// <summary> /// Create a new Message for Publishing to an Exchange /// </summary> /// <param name="client">A <see cref="RabbitMQClient"/> Instance</param> /// <param name="exchange">The Exchange to Publish this Message to</param> /// <param name="routingKey">The Routing Key for this Message</param> /// <param name="type">The Type of Message</param> /// <param name="mode">The Publishing Mode for this Message</param> /// <returns>A New <see cref="PublishMessage"/> Instance ready to be Customized before Publishing</returns> public static PublishMessage CreateNew(RabbitMQClient client, string exchange, string routingKey, string type = "", PublishMode mode = PublishMode.BrokerConfirm) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (exchange == null) { throw new ArgumentNullException(nameof(exchange)); } if (routingKey == null) { throw new ArgumentNullException(nameof(routingKey)); } #if NETSTANDARD TimeSpan publishTimeout = client.DefaultPublishTimeout ?? TimeSpan.FromMilliseconds(client.HeartbeatInterval.TotalMilliseconds * 2); #else TimeSpan publishTimeout = client.DefaultPublishTimeout ?? client.HeartbeatInterval.Multiply(2); #endif return(new PublishMessage(client.DefaultPublishRetries) { Exchange = exchange, RoutingKey = routingKey, Mode = mode, Type = type, PublishTimeout = publishTimeout, PublishRetries = client.DefaultPublishRetries, }); }
public async Task CreatePublishAndConsume() { var connectionFactory = CreateConnectionFactory(); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; queueClient.EnsureQueueExists(queueName, autoDelete:true); queueClient.Publish("", queueName, "TestValue123"); var receivedMessage = ""; var worker = await SimpleMessageProcessingWorker<string>.CreateAndStartAsync(queueClient, queueName, message => DoSomething(message, out receivedMessage), CancellationToken.None); const int timeLimit = 10000; var elapsedTime = 0; while (receivedMessage == "" && elapsedTime < timeLimit) { await Task.Delay(100); elapsedTime += 100; } worker.Stop(); receivedMessage.ShouldBe("TestValue123"); } }
public async Task AdvancedCreatePublishAndConsume() { var connectionFactory = CreateConnectionFactory(); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; queueClient.EnsureQueueExists(queueName, autoDelete: true); queueClient.Publish("", queueName, "TestValue123"); var receivedMessage = ""; var worker = await AdvancedMessageProcessingWorker <string> .CreateAndStartAsync(queueClient, queueName, message => DoSomething(message, out receivedMessage), CancellationToken.None); const int timeLimit = 10000; var elapsedTime = 0; while (receivedMessage == "" && elapsedTime < timeLimit) { await Task.Delay(100); elapsedTime += 100; } worker.Stop(); receivedMessage.ShouldBe("TestValue123"); } }
/// <summary> /// Create a new Message for Publishing a Reply directly to a Queue /// </summary> /// <param name="client">A <see cref="RabbitMQClient"/> Instance</param> /// <param name="replyTo">The Name of the Queue to Directly Publish to</param> /// <param name="receivedMessageId">The ID of the Message that is being Replied to</param> /// <param name="type">The Type of Message</param> /// <param name="mode">The Publishing Mode for this Message</param> /// <returns>A New <see cref="PublishMessage"/> Instance ready to be Customized before Publishing</returns> public static PublishMessage CreateNew(RabbitMQClient client, string replyTo, Guid receivedMessageId, string type = "", PublishMode mode = PublishMode.BrokerConfirm) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (replyTo == null) { throw new ArgumentNullException(nameof(replyTo)); } if (receivedMessageId == Guid.Empty) { throw new ArgumentOutOfRangeException(nameof(receivedMessageId), "The Received Message ID cannot be an Empty GUID"); } #if NETSTANDARD TimeSpan publishTimeout = client.DefaultPublishTimeout ?? TimeSpan.FromMilliseconds(client.HeartbeatInterval.TotalMilliseconds * 2); #else TimeSpan publishTimeout = client.DefaultPublishTimeout ?? client.HeartbeatInterval.Multiply(2); #endif return(new PublishMessage(client.DefaultPublishRetries) { Exchange = "", RoutingKey = replyTo, Mode = mode, Type = type, PublishTimeout = publishTimeout, PublishRetries = client.DefaultPublishRetries, CorrelationID = receivedMessageId, }); }
public async Task DelayedPublish() { var connectionFactory = CreateConnectionFactory(); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; try { queueClient.QueueDeclare(queueName); queueClient.ExchangeDeclare("delayedTargetExchange"); queueClient.QueueBind(queueName, "delayedTargetExchange", "delayedTargetRoutingKey"); queueClient.DelayedPublish("delayedTargetExchange", "delayedTargetRoutingKey", "delayedMessage", TimeSpan.FromSeconds(5)); queueClient.GetMessageCount(queueName).ShouldBe <uint>(0); await Task.Delay(TimeSpan.FromSeconds(5)); queueClient.GetMessageCount(queueName).ShouldBe <uint>(1); } finally { queueClient.QueueDelete(queueName); } } }
public IHttpActionResult GenerateFibonacciSeries([FromBody] FibonacciRange req) { try { RabbitMQClient client = new RabbitMQClient(); GenerateFibonacciPosRange fr = new GenerateFibonacciPosRange(); BigInteger[] results = new BigInteger[req.EndPosition - req.StartPosition + 1]; results = fr.GetSeriesBetweenPosition(req.StartPosition, req.EndPosition); foreach (decimal num in results) { req.result += num.ToString() + ", "; } //req.result = results.ToString(); client.SendFibonacciSeries(req); client.Close(); } catch (Exception) { return(StatusCode(HttpStatusCode.BadRequest)); } return(Ok(req)); }
static void Main(string[] args) { //SendPayment(payment); //ClientListen(payment); Console.WriteLine("[+] Starting..."); cpuCounter = new PerformanceCounter(); cpuCounter.CategoryName = "Processor"; cpuCounter.CounterName = "% Processor Time"; cpuCounter.InstanceName = "_Total"; ramCounter = new PerformanceCounter("Memory", "Available MBytes"); client = new RabbitMQClient(conversationId); try { System.Timers.Timer t = new System.Timers.Timer(1200); t.Elapsed += new ElapsedEventHandler(TimerElapsed); t.Start(); Thread.Sleep(10000); } catch (Exception e) { Console.WriteLine("catched exception"); } Console.ReadLine(); }
void Awake() { taiwanMap = FindObjectOfType <TaiwanMap>(); terrain = FindObjectOfType <Terrain>(); messageBroker = FindObjectOfType <RabbitMQClient>(); troopManager = FindObjectOfType <TroopManager>(); twTerrainCam = FindObjectOfType <Camera>(); }
public SocialOryxlWSHandler( RabbitMQClient _rabbitMQClient, SocialMsgManager _socialMsgManager ) { rabbitMQClient = _rabbitMQClient; socialMsgManager = _socialMsgManager; }
public IndexModel(IHostingEnvironment hostingEnvironment, ImageService imageService, RabbitMQClient mQClient) { _hostingEnvironment = hostingEnvironment; _imageService = imageService; _mQClient = mQClient; }
public IActionResult MakePayment([FromBody] CardPayment payment) { RabbitMQClient client = new RabbitMQClient(); client.SendPayment(payment); client.Close(); return(Ok(payment)); }
public IActionResult MakePayment([FromBody] PurchaseOrder payment) { RabbitMQClient client = new RabbitMQClient(); client.SendPurchaseOrder(payment); client.Close(); return(Ok(payment)); }
/// <summary> /// 构造函数 /// </summary> /// <param name="serviceName"></param> public QueueThread(String serviceName, RabbitMQClient rabbitMQClient) { m_ServiceName = serviceName; m_RabbitMQ = rabbitMQClient; m_Thread = new Thread(x => { ProcessInvokeQueueMessage(); }); }
public WxqFuncController(OryxWebSocketPool _wsPool, VoteAppDbContext _dbContext, RabbitMQClient _rabbitMqClient ) { wsPool = _wsPool; dbContext = _dbContext; rabbitMqClient = _rabbitMqClient; }
/// <summary> /// Create a new Message with Binary (byte) Content for Publishing a Reply directly to a Queue /// </summary> /// <param name="client">A <see cref="RabbitMQClient"/> Instance</param> /// <param name="replyTo">The Name of the Queue to Directly Publish to</param> /// <param name="receivedMessageId">The ID of the Message that is being Replied to</param> /// <param name="bytes">The Binary (byte) Data for this Message</param> /// <param name="type">The Type of Message</param> /// <param name="mode">The Publishing Mode for this Message</param> /// <returns>A New <see cref="BinaryPublishMessage"/> Instance ready to be Published</returns> public static PublishMessage CreateNew(RabbitMQClient client, string replyTo, Guid receivedMessageId, ReadOnlyMemory <byte> bytes, string type = "", PublishMode mode = PublishMode.BrokerConfirm) { PublishMessage message = CreateNew(client, replyTo, receivedMessageId, type, mode); message.Body = bytes; message.ContentType = ContentTypes.Binary; return(message); }
/// <summary> /// Create a new Message with Binary (byte) Content for Publishing to an Exchange /// </summary> /// <param name="client">A <see cref="RabbitMQClient"/> Instance</param> /// <param name="exchange">The Exchange to Publish this Message to</param> /// <param name="routingKey">The Routing Key for this Message</param> /// <param name="bytes">The Binary (byte) Data for this Message</param> /// <param name="type">The Type of Message</param> /// <param name="mode">The Publishing Mode for this Message</param> /// <returns>A New <see cref="BinaryPublishMessage"/> Instance ready to be Published</returns> public static PublishMessage CreateNew(RabbitMQClient client, string exchange, string routingKey, ReadOnlyMemory <byte> bytes, string type = "", PublishMode mode = PublishMode.BrokerConfirm) { PublishMessage message = CreateNew(client, exchange, routingKey, type, mode); message.Body = bytes; message.ContentType = ContentTypes.Binary; return(message); }
static void Main(string[] args) { IRabbitMQClient client = new RabbitMQClient(new UriRabbitMqConfiguration("GPSLocation", "amqp://*****:*****@clam.rmq.cloudamqp.com/kkxglvxw") ); client.ReceiveMessages(x => Console.WriteLine(x)); Console.ReadKey(); }
public FingerprintsController() { fingerprintService = new FingerprintService(); SERVER_IP = ConfigurationManager.AppSettings["iClockHost"] ?? "10.62.0.23"; if (_client == null) { _client = new RabbitMQClient("Fingerprint Monitor Queue"); } }
public SocialMsgManager( IDistributedCache _distributedCache, OryxWebSocketPool _wsPool, RabbitMQClient _rabbitMQClient ) { distributedCache = _distributedCache; wsPool = _wsPool; rabbitMQClient = _rabbitMQClient; }
static void Main(string[] args) { AdminRun.Run(); if (!SetConsoleCtrlHandler(cancelHandler, true)) { Console.WriteLine("程序监听系统按键异常"); } try { //1.MEF初始化 MefConfig.Init(); //2.数据库初始化连接 ConfigInit.InitConfig(); //3.系统参数配置初始化 ConfigManager configManager = MefConfig.TryResolve <ConfigManager>(); configManager.Init(); Console.Title = SystemConfig.ProgramName; Console.CursorVisible = false; //隐藏光标 //4.任务启动 QuartzHelper.InitScheduler(); QuartzHelper.StartScheduler(); //5.加载SQL信息到缓存中 XmlCommandManager.LoadCommnads(SysConfig.XmlCommandFolder); //测试dapper orm框架 //DapperDemoService.Test(); //启动站点 using (NancyHost host = Startup.Start(SystemConfig.WebPort)) { //调用系统默认的浏览器 string url = string.Format("http://127.0.0.1:{0}", SystemConfig.WebPort); Process.Start(url); Console.WriteLine("系统已启动,当前监听站点地址:{0}", url); //4.消息队列启动 RabbitMQClient.InitClient(); //5.系统命令初始化 CommandHelp.Init(); } } catch (Exception ex) { Console.WriteLine(ex); } Console.Read(); }
private void InitialiseProducer() { _rabbitClient = RabbitMQClient.Configure(x => { x.HostName = HostName; x.Password = Password; x.UserName = UserName; }).Create(); _producer = _rabbitClient.GetProducer <Data>(ExchangeName, QueueName, _dataSerializer.ToProto); }
public void Stop() { client.CloseConnection(); client = null; fingerPrinterManager.Stop(); fingerPrintThread.Join(1000); if (fingerPrintThread.IsAlive) { fingerPrintThread.Abort(); } }
/// <summary> /// /// </summary> /// <param name="host"></param> /// <param name="userName"></param> /// <param name="pwd"></param> /// <param name="loger"></param> public TracingRecordRabbitmq(string host, string userName, string pwd, ILoger loger = null) { Raven.Rpc.Tracing.Record.RabbitMQ.Options rabbitMQOptions = new Options(); rabbitMQOptions.SerializerType = SerializerType.NewtonsoftJson; rabbitMQOptions.HostName = host; rabbitMQOptions.UserName = userName; rabbitMQOptions.Password = pwd; rabbitMQOptions.Loger = loger; rabbitMQClient = RabbitMQClient.GetInstance(rabbitMQOptions); }
/// <summary> /// /// </summary> /// <param name="host"></param> /// <param name="userName"></param> /// <param name="pwd"></param> /// <param name="loger"></param> public TracingRecordRabbitmq(string host, string userName, string pwd, MessageQueue.ILoger loger = null) { Raven.MessageQueue.WithRabbitMQ.Options rabbitMQOptions = new Options(); rabbitMQOptions.SerializerType = SerializerType.NewtonsoftJson; rabbitMQOptions.HostName = host; rabbitMQOptions.UserName = userName; rabbitMQOptions.Password = pwd; rabbitMQOptions.Loger = loger; rabbitMQClient = RabbitMQClient.GetInstance(rabbitMQOptions); }
public async Task UpdateStock_Test() { // Arrange var stockRep = new StockTradingRepository(new AmazonDynamoDBClient()); var oldStock = new StockDB(); oldStock.Name = "SendStockTestUpdate"; oldStock.Price = 123.45f; oldStock.LastUpdated = System.DateTime.Now.ToString(); var newStock = new StockDB(); newStock.Name = "SendStockTestUpdate"; newStock.Price = 678.90f; newStock.LastUpdated = System.DateTime.Now.ToString(); // Act await stockRep.AddStock(oldStock); var result1 = await stockRep.GetItem(oldStock.Name); await stockRep.UpdateStock(newStock); var result2 = await stockRep.GetItem(newStock.Name); // Assert Assert.AreNotEqual(result1.Price, result2.Price); // Clean-up await stockRep.DeleteStock(newStock); // Clean up messages // Initiate RabbitMQ RabbitMQClient client = new RabbitMQClient("Patch_Queue", "stock.patch"); ConnectionFactory _factory; IConnection _connection; IModel _model; _factory = new ConnectionFactory { HostName = "localhost", UserName = "******", Password = "******" }; _connection = _factory.CreateConnection(); _model = _connection.CreateModel(); _model.QueuePurge("Add_Queue"); _model.QueuePurge("Delete_Queue"); _model.QueuePurge("Patch_Queue"); }
public async Task UpdateStock(StockDB stockDB) { // create a new queue for each operation RabbitMQClient client = new RabbitMQClient("Patch_Queue", "stock.patch"); client.SendMethod(stockDB, "stock.patch"); client.Close(); // update to dynamoDB await _context.SaveAsync(stockDB); }
public async Task DeleteStock(StockDB stockDB) { // create a new queue for each operation RabbitMQClient client = new RabbitMQClient("Delete_Queue", "stock.delete"); client.SendMethod(stockDB, "stock.delete"); client.Close(); // delete from dynamoDB await _context.DeleteAsync(stockDB); }
public async Task AddStock(StockDB stockDB) { // create a new queue for each operation RabbitMQClient client = new RabbitMQClient("Add_Queue", "stock.add"); client.SendMethod(stockDB, "stock.add"); client.Close(); // save to dynamoDB await _context.SaveAsync(stockDB); }
public void TestMethod1() { MQConfig config = new MQConfig("localhost", "guest", "guest") { VirtualHost = "/" }; RabbitMQClient client = new RabbitMQClient(config); client.Pull <MqModel>((x) => { Console.WriteLine(x.ToJson()); }); }
public HttpResponseMessage Post(Message message) { using (var rabbitMQ = new RabbitMQClient()) { rabbitMQ.Channel.BasicPublish( exchange: "", routingKey: "hello", basicProperties: null, body: SerializeMessage(message)); } return(Request.CreateResponse(HttpStatusCode.Created)); }
public RabbitMQClientManager() { RabbitMQConfig rabbitMQConfig = new RabbitMQConfig("RabbitMQ_RavenLogs"); rabbitMQOptions = new Raven.MessageQueue.WithRabbitMQ.Options() { SerializerType = SerializerType.NewtonsoftJson, HostName = rabbitMQConfig.hostName, Password = rabbitMQConfig.password, UserName = rabbitMQConfig.username, //MaxQueueCount = 100000, Loger = new Loger() }; rabbitMQClient = RabbitMQClient.GetInstance(rabbitMQOptions); }
/// <summary> /// 构造器 /// </summary> public RabbitQueueManager() { ESBConfig esbConfig = m_ESBProxy.RegistryConsumerClient.ESBConfig; if (esbConfig != null && esbConfig.MessageQueue.Count > 0) { //String esbQueue = Config.GetConfig<String>("ESB.Queue"); String esbQueue = esbConfig.MessageQueue[0].Uri; XTrace.WriteLine("读取到ESB队列地址:{0}", esbQueue); String[] paramMQ = esbQueue.Split(':'); m_RabbitMQ = new RabbitMQClient(paramMQ[0], paramMQ[2], paramMQ[3], Int32.Parse(paramMQ[1])); } else { String err = "无法获取到有效的队列地址!"; XTrace.WriteLine(err); throw new Exception(err); } }
public async Task CreateBatchPublishAndConsume() { var connectionFactory = CreateConnectionFactory(); const int messageAmount = 100; var messages = GenerateMessages(messageAmount); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; queueClient.EnsureQueueExists(queueName); queueClient.BatchPublish("", queueName, messages); var receivedMessages = new ConcurrentBag<string>(); var worker = await SimpleMessageProcessingWorker<string>.CreateAndStartAsync(queueClient, queueName, message => BatchDoSomething(message, receivedMessages), CancellationToken.None); const int timeLimit = 10000; var elapsedTime = 0; while (receivedMessages.Count < messageAmount && elapsedTime < timeLimit) { await Task.Delay(100); elapsedTime += 100; } worker.Stop(); queueClient.QueueDelete(queueName); receivedMessages.Count.ShouldBe(messages.Count); receivedMessages.ShouldBeSubsetOf(messages); } }
public async Task ConsumerScaling() { var connectionFactory = CreateConnectionFactory(); int messageAmount = 30000; var messages = GenerateMessages(messageAmount); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; queueClient.EnsureQueueExists(queueName); queueClient.BatchPublish("", queueName, messages); var worker = await SimpleMessageProcessingWorker<string>.CreateAndStartAsync(queueClient, queueName, async message => await Task.Delay(20), CancellationToken.None, new ConsumerCountManager(4, 50, 1000, 2000)); const int timeLimit = 1200000; var elapsedTime = 0; while (elapsedTime < timeLimit) { await Task.Delay(100); elapsedTime += 100; if (elapsedTime%1000 == 0 && messageAmount < 70000) { messages = GenerateMessages(1000); queueClient.BatchPublish("", queueName, messages); messageAmount += 1000; } } worker.Stop(); queueClient.QueueDelete(queueName); } }
public async Task DelayedPublish() { var connectionFactory = CreateConnectionFactory(); using (var queueClient = new RabbitMQClient(connectionFactory)) { var queueName = $"IntegratedTestQueue_{Guid.NewGuid()}"; try { queueClient.QueueDeclare(queueName); queueClient.ExchangeDeclare("delayedTargetExchange"); queueClient.QueueBind(queueName, "delayedTargetExchange", "delayedTargetRoutingKey"); queueClient.DelayedPublish("delayedTargetExchange", "delayedTargetRoutingKey", "delayedMessage", TimeSpan.FromSeconds(5)); queueClient.GetMessageCount(queueName).ShouldBe<uint>(0); await Task.Delay(TimeSpan.FromSeconds(5)); queueClient.GetMessageCount(queueName).ShouldBe<uint>(1); } finally { queueClient.QueueDelete(queueName); } } }
/// <summary> /// 配置队列线程 /// </summary> private void ConfigQueueThread() { String appName = m_ConsumerConfig.ApplicationName; if (m_EsbConfig.ServiceConfig != null && m_EsbConfig.ServiceConfig.Count > 0) { //--根据QueueCenter的消费者配置文件中的ApplicationName找到和本机相关的配置文件 List<EsbView_ServiceConfig> lstServcieConfig = m_EsbConfig.ServiceConfig.FindAll(x =>{ return !String.IsNullOrEmpty(x.QueueCenterUri) && appName.EndsWith(x.QueueCenterUri); }); //--删除不应该由本机消费的队列并停用相关线程 DeleteQueueThread(lstServcieConfig); //--添加本机应该消费的队列 foreach (EsbView_ServiceConfig sc in lstServcieConfig) { if (!m_QueueThreadDict.ContainsKey(sc.ServiceName)) { RabbitMQClient rabbitMQ = new RabbitMQClient(m_ParamMQ[0], m_ParamMQ[2], m_ParamMQ[3], Int32.Parse(m_ParamMQ[1])); QueueThread qt = new QueueThread(sc.ServiceName, rabbitMQ); qt.Start(); m_QueueThreadDict[sc.ServiceName] = qt; } } } else { //--删除不应该由本机消费的队列并停用相关线程 DeleteQueueThread(null); } }