精华内容
下载资源
问答
  • 在一个线程中通过调用 int MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType); 弹出系统的模态窗口,此窗口有两个按钮:确定和取消,如何在一个线程中通过发送win32消息来模拟用户点击...
  • SendMessage可以发送消息,然后当前线程阻塞,窗口(主线程)会队列得到这消息,这是看调用栈看的,具体原理有待研究。 例如: SendMessage(dlgMain.m_hWnd, WM_COMMAND, (WPARAM)(IDCANCEL), 0); 还有, ...

    PostThreadMessage 发送的消息都不会发送到窗口,因为没有窗口句柄。只有 WM_QUIT 起作用,除非消息循环自己来写。

    SendMessage可以发送消息,然后当前线程阻塞,窗口(主线程)会在队列中得到这个消息,这个是看调用栈看的,具体原理有待研究。
    例如:
    SendMessage(dlgMain.m_hWnd, WM_COMMAND, (WPARAM)(IDCANCEL), 0);

    还有,在 WTL 中,如果发送 WM_DESTROY,会导致 dlgMain 析构的时候 m_hwnd 没有释放。具体为什么有待研究。

    展开全文
  • 会发生一个线程中的ResultSet还被操作时,已经被另一个线程中的ResultSet关闭的情况 我试过了 DataHandle中Synchronized(rs),synchronized(stmt),甚至我的方法大家都看到了,都是synchronized的,为什么还会...
  • 我相信OP的目的是从请求处理程序关闭服务器,我认为他的代码的KeyboardInterrupt方面只是令人困惑的事情。运行服务器的shell按...不需要像OP尝试的那样处理handle()的KeyboardInterrupt,或者像另一个建议的那...

    我相信OP的目的是从请求处理程序关闭服务器,我认为他的代码的KeyboardInterrupt方面只是令人困惑的事情。

    在运行服务器的shell中按ctrl-c将成功地在不做任何特殊操作的情况下关闭它。你不能从一个不同的shell按ctrl-c并期望它工作,我认为这个概念可能是这个混乱的代码的来源。不需要像OP尝试的那样处理handle()中的KeyboardInterrupt,或者像另一个建议的那样处理serve_forever()中的KeyboardInterrupt。如果你两个都不做,它就会按预期工作。

    这里唯一的诀窍——而且很棘手——是告诉服务器在不死锁的情况下从处理程序关闭。

    正如OP在他的代码中解释和显示的那样,他使用的是单线程服务器,因此建议在“其他线程”中关闭它的用户没有注意到。

    我仔细研究了SocketServer代码,发现BaseServer类在处理该模块中可用的线程混合时,实际上通过在serve_forever中使用threading.Event循环,使非线程服务器的使用更加困难。

    因此,我为单线程服务器编写了serve_forever的修改版本,这使得从请求处理程序关闭服务器成为可能。import SocketServer

    import socket

    import select

    class TCPServerV4(SocketServer.TCPServer):

    address_family = socket.AF_INET

    allow_reuse_address = True

    def __init__(self, server_address, RequestHandlerClass):

    SocketServer.TCPServer.__init__(self, server_address, RequestHandlerClass)

    self._shutdown_request = False

    def serve_forever(self, poll_interval=0.5):

    """provide an override that can be shutdown from a request handler.

    The threading code in the BaseSocketServer class prevented this from working

    even for a non-threaded blocking server.

    """

    try:

    while not self._shutdown_request:

    # XXX: Consider using another file descriptor or

    # connecting to the socket to wake this up instead of

    # polling. Polling reduces our responsiveness to a

    # shutdown request and wastes cpu at all other times.

    r, w, e = SocketServer._eintr_retry(select.select, [self], [], [],

    poll_interval)

    if self in r:

    self._handle_request_noblock()

    finally:

    self._shutdown_request = False

    class TCPHandler(SocketServer.BaseRequestHandler):

    def handle(self):

    data = self.request.recv(4096)

    if data == "shutdown":

    self.server._shutdown_request = True

    host = 'localhost'

    port = 52000

    server = TCPServerV4((host, port), TCPHandler)

    server.serve_forever()

    如果将字符串'shutdown'发送到服务器,服务器将结束其serve_forever循环。您可以使用netcat进行测试:printf "shutdown" | nc localhost 52000

    展开全文
  • 利用TerminateThread()安全的关闭执行一个线程 BOOL TerminateThread(  HANDLE hThread, // handle to thread  DWORD dwExitCode // exit code线程的结束代码 ); 该函数会引来许多问
    如何在某个线程内终止另一个正在运行的线程?

    --------干净地终止一个线程
    利用TerminateThread()安全的关闭执行中的一个线程
    BOOL TerminateThread(
      HANDLE hThread,    // handle to thread
      DWORD dwExitCode   // exit code线程的结束代码
    );

    该函数会引来许多问题,如果内存泄露。尽量不使用TerminateThread()
    下面利用event对象来干净的结束一个线程
    /*
     * 
     * Demonstrates how to request threads to exit.
     * 结束线程
     * 
     */
    
    
    #define WIN32_LEAN_AND_MEAN
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    #include <time.h>
    
    
    
    
    DWORD WINAPI ThreadFunc(LPVOID);
    
    
    HANDLE hRequestExitEvent = FALSE;
    
    
    int main()
    {
        HANDLE hThreads[2];
        DWORD dwThreadId;
        DWORD dwExitCode = 0;
        int i;
    
    
        hRequestExitEvent = CreateEvent(
            NULL, TRUE, FALSE, NULL);
    	//创建event对象,一开始处于未激发状态,靠程序来设置激发
    
    
        for (i=0; i<2; i++)
           hThreads[i] = CreateThread(NULL,
                0,
                ThreadFunc,
                (LPVOID)i,
                0,
                &dwThreadId);
           
    
    
        // Wait around for awhile, make
        // sure the thread is running.
        Sleep(1000);//保证线程可以运行
    
    
        SetEvent(hRequestExitEvent);//设置event激发状态通知线程退出
        WaitForMultipleObjects(2, hThreads, TRUE, INFINITE);//主线程退出之前,确保其他线程已经安全退出
    
    
        for (i=0; i<2; i++)
            CloseHandle(hThreads[i]);
    
    
        return EXIT_SUCCESS;
    }
    
    
    DWORD WINAPI ThreadFunc(LPVOID p)
    {
        int i;
        int inside = 0;
    
    
        UNREFERENCED_PARAMETER(p);
    
    
        /* Seed the random-number generator */
        srand( (unsigned)time( NULL ) );
    
    
        for (i=0; i<1000000; i++)
        {
            double x = (double)(rand())/RAND_MAX;
            double y = (double)(rand())/RAND_MAX;
            if ( (x*x + y*y) <= 1.0 )
                inside++;
            if (WaitForSingleObject(hRequestExitEvent, 0) != WAIT_TIMEOUT) //等待event对象的激发状态
            {
                printf("Received request to terminate\n");  //当收到event激发,则退出
                return (DWORD)-1;
            }
        }
        printf("PI = %.4g\n", (double)inside / i * 4);
        return 0;
    }
    

    -----线程优先权(Thread Priority)

    优先权类别:它是进程的属性之一。这个属性可以表现出这一个进程和其他进程比较之下的重要性。Win32提供4种优先权类别。每一个类别对应一个基本的优先权层级。
    优先权类别                                  基础优先权值
    HIGH_PRIORITY_CLASS                            13
    IDLE_PRIORITY_CLASS                             4
    NORMAL_PRIORITY_CLASS                           7or8(大部分程序使用的)
    REALTIME_PRIORITY_CLASS                          24
    优先权类别适用于进程而非线程。可以利用SetPriortiyClass()和GetPriorityClass()来调整和验证其值。


    优先权层级:线程的优先权层级是对进程的优先权类别的一个修改,使得你能够调整同一个进程内的各个线程的相对重要性。一共有七种优先权层级。

    优先级层级                                                         调整值
     HTREAD_PRIORITY_HIGHEST                      +2
    HTREAD_PRIORITY_ABOVE_NORMAL          +1
    HTREAD_PRIORITY_NORMAL                        0
    HTREAD_PRIORITY_BELOW_NORMAL          -1
    HTREAD_PRIORITY_LOWEST                        -2
    HTREAD_PRIORITY_IDLE                                 set to 1
    HTREAD_PRIORITY_TIME_CRITICAL                set to 15


    优先权层级利用SetThreadPriority()改变。
    BOOL SetThreadPriority(
      HANDLE hThread, // handle to the thread
      int nPriority   // thread priority level
    );

    获取目前线程的优先权GetThreadPriority()
    int GetThreadPriority(
      HANDLE hThread   // handle to thread
    );

    创建一个线程,但是不要马上执行:

    HANDLE hThread;
    DWORD threadId;
    hThread=CreateThread(NULL,0,THreadFunc,0,CREATE_SUSPENDED,&threadId);
    一旦线程设定妥当,可以调用ResumeThread()开始执行。
    DWORD ResumeThread(
      HANDLE hThread   // handle to thread
    );

    ---挂起一个线程

    SuspendThread()允许调用端指定一个线程睡眠。直到又有人调用了ResumeThread(),这个线程才会醒来。
    DWORD SuspendThread(
      HANDLE hThread   // handle to thread
    );
    SuspendThread()的最大用途就是用来协调撰写调试器。调试器允许在程序的控制下,启动或停止任何一个线程。
    展开全文
  • 创建线程的方式继承Thread类,重写run方法调用thread.start()方法Thread类的几个常用方法:1. currentThread() 返回当前正在执行的线程的... join() 使当前线程等待另一个线程执行完毕之后再继续执行,内部调用O...

    c39220aaefd5af7ac4bbd3fa8db8b136.png

    创建线程的方式

    继承Thread类,重写run方法

    调用thread.start()方法

    Thread类的几个常用方法:

    1. currentThread() 返回当前正在执行的线程的引用

    2. start() 开始执行线程

    3. yield() 当前线程愿意让出对当前处理器的占用

    4. sleep() 静态方法,是线程睡眠一段时间

    5. join() 使当前线程在等待另一个线程执行完毕之后再继续执行,内部调用Object类的wait()方法实现的

    实现Runnable接口

    new Thread(new Runnable() {

    @Override

    public void run() {

    }

    }).start();

    ThreadFactory 优势在于统一规格的初始化,如线程名

    ThreadFactory factory = new ThreadFactory() {

    @Override

    public Thread newThread(@NotNull Runnable r) {

    return new Thread(r,"线程名");

    }

    };

    Runnable runnable = new Runnable() {

    @Override

    public void run() {

    }

    };

    Thread thread =factory.newThread(runnable);

    thread.start();

    线程池创建

    Runnable runnable = new Runnable() {

    @Override

    public void run() {

    }

    };

    Executor executor = Executors.newCachedThreadPool(); //带缓存的线程池

    executor.execute(runnable);

    ExectorService是Exector的子接口
    扩展了showdown()保守型结束,showdownNow立刻结束,回收线程

    Executors.newFixedThreadPool()做一次性的批量操作

    自定义线程池

    /**

    *

    * @param corePoolSize 核心线程数

    * @param maximumPoolSize 最大线程数

    * @param keepAliveTime 等待时间回收

    * @param unit 单位

    * @param workQueue 阻塞式队列,用来存runnable的

    */

    public ThreadPoolExecutor(int corePoolSize,

    int maximumPoolSize,

    long keepAliveTime,

    TimeUnit unit,

    BlockingQueue<Runnable> workQueue) {

    }

    Callable 带返回值的Runnable

    Callable<String> callable = new Callable<String>() {

    @Override

    public String call() throws Exception {

    Thread.sleep(2000);

    return "Done!";

    }

    };

    try {

    ExecutorService executor = Executors.newCachedThreadPool();

    Future<String> future = executor.submit(callable);

    String result = future.get();

    System.out.println("result:" + result);

    } catch (InterruptedException | ExecutionException e) {

    e.printStackTrace();

    }

    线程同步与线程安全

    Synchronized(可修饰方法,代码块)

    • 保证⽅法内部或代码块内部资源(数据)的互斥访问。即同⼀时间、由同⼀个Monitor 监视的代码,最多只能有⼀个线程在访问
    • 保证线程之间对监视资源的数据同步。即,任何线程在获取到 Monitor 后的第⼀时间,会先将共享内存中的数据复制到⾃⼰的缓存中;任何线程在释放Monitor 的第⼀时间,会先将缓存中的数据复制到共享内存中。

    volatile 只对赋值有效,赋引用有效

    • 保证加了 volatile关键字的字段的操作具有原⼦性和同步性,其中原⼦性相当于实现了针对单⼀字段的线程间互斥访问。因此 volatile 可以看做是简化版的 synchronized。
    • volatile 只对基本类型(byte、char、short、int、long、float、double、boolean) 的赋值操作和对象的引⽤赋值操作有效。

    java.util.concurrent.atomic包

    • AtomicReference<>引用

    AtomicInteger atomicInteger =new AtomicInteger(0);

    atomicInteger.getAndIncrement();

    • Lock/ReentrantReadWriteLock

    Lock lock =new ReentrantLock();

    lock.lock();

    ...代码片段用try catch包裹

    lock.unlock();

    //读写锁

    ReentrantReadWriteLock lock =new ReentrantReadWriteLock();

    Lock readlock =lock.readLock();

    Lock writelock =lock.writeLock();

    readlock.lock();

    //...读代码

    readlock.unlock();

    writelock.lock();

    //...写代码

    wretelock.unlock();

    读的时候其他线程可以读不能写,写的时候其他线程不能读也不能写==

    线程安全问题本质

    在多个线程访问共同资源时,当某个线程对资源进行写操作的中途(写入已经开始,但还没有结束),其他线程对这个写了一半的资源进行了读操作,或者基于这个写了一半的线程进行了写操作,导致出现数据错误

    线程间通信的本质和原理以及Android中的多线程

    线程间交互

    • 启动: new Thread().start(); Executor.execute()等
    • 终结: ==~~Thread.stop()~~== 强制结束 ==Thread.interrupt()== 温和式终结:不立即不强制,Thread.interrupted和isInterrupted检查中断状态
    • Object.wait()和Object.notify()/Object.notifyAll(). 在未达到目标是wait,while循环检查,设置完成后notifyAll(),wait()/notify()都需要放在synchronized块里边
    • Thread.join() 让另外一个线程插在自己前面
    • Thread.yield() 暂时让出时间片给同优先级的线程

    Android的Handler机制

    HandlerThread: 具体的线程

    Looper :负责循环,条件判断和任务执行

    Handler:负责任务的定制和线程间传递

    AsyncTask的内存泄露原因:

    1、内部类持有外部类Activity的引用

    2、执行中的线程不会被系统回收

    Java内存回收策略:

    没有被GCRoot直接或间接持有引用的对象会被回收。

    GC Root:

    1. 运行中的线程

    2. 静态对象

    3. 来自native code的引用

    AsyncTask 的内存泄露,其他类型的线程⽅案(Thread、Executor、
    HandlerThread)⼀样都有,所以不要忽略它们,或者认为 AsyncTask ⽐别的⽅
    案更危险。并没有。
    就算是使⽤ AsyncTask,只要任务的时间不⻓(例如 10 秒之内),那就完全没
    必要做防⽌内存泄露的处理。

    Service:后台任务的活动空间。适用于音乐播放器

    IntentService:执行单个任务后自动关闭的Service

    ExecutorAsyncTaskHandlerThreadIntentService的选择

    - 能用Executor就用Executor

    - 需要用到后台线程推送任务到UI线程时,再考虑AsyncTask,或Handler

    - HandlerThread使用场景:在已经运行的指定线程上执行代码,androidUi线程用到,继承自Thread,run方法里初始化了Looper

    - IntentService:继承自Service,内部使用HandlerThread和Looper来实现,实质上是在Service生命周期方法通过HandlerThread,Looper,Handler做相应的处理

    Executor和HandlerThread的关闭

    @Override

    protected void onDestroy() {

    super.onDestroy();

    executor.shutdown();

    handlerThread.quit(); // 这个其实就是停⽌ Looper 的循环

    }

    展开全文
  • .net的WinForm程序,如果是直接起动的Form作为主窗口,那么这个主窗口是不能关闭的,因为它...如何使用Hide()(只是隐藏,其实进程还被占用着)之类或者Close()(这个操作会把所有窗体关闭,因为属于同一个线程...
  • 您可以处理程序本地启动另一个线程,然后从那里调用shutdown.工作演示:#!/usr/bin/env python# -*- coding: UTF-8 -*-import SimpleHTTPServerimport SocketServerimport timeimport threadclass MyHandler...
  • 一个线程中访问控件,或对控件进行操作的时候,如调用SetWindowText,当窗口关闭时,有可能产生一个错误.原因在于:窗口关闭时,控件先销毁,然后销毁线程,当控件销毁时,若线程继续访问控件的话,则会出错.可能是...
  • JMETER: setUP线程组:测试任务Thread...为了加深影响,来另一个性能测试工具 LoadRunner: vusers_init: 一 般是用来做初始化的事情 比如要测试业务某个具体业务操作环节时,可以先把系统用户登录的写int..
  • 那每次打开的时候是不是要用线程中的暂停啊,关闭的时候恢复线程 求解惑? private void btnLoad_Click(object sender, RoutedEventArgs e) { MainWindow obj = new MainWindow(); Thread thread = new Thread(new ...
  • 守护线程(即daemon thread),是个服务线程,是一类后台运行的特殊进程,用于执行特定的系统任务。...用户使守护进程独立于所有终端是因为,守护进程从一个终端启动的情况下,这同一个终端可能被其他的用户使用
  • 小编典典事实:webapp的生存期内只有一个servlet实例。它是webapp启动时创建的,webapp关闭时销毁的。请参见此答案以进行粗略的解释。因此,它已所有请求(线程)之间共享。如果将请求或会话范围的数据分配...
  • SWT线程开发,如果使用一个线程去访问另一个线程,则需要使用到Display对象的asyncExce方法,或者syncExce方法;在关闭前台窗口时,需要将后台工作停止。由于是多线程,前台窗口关闭后,后台...
  • 例如,如果多个线程尝试同一个文件写入,那么它们可能会破坏数据,因为其中一个线程可以覆盖数据,或者当一个线程同时打开同一个文件时,另一个线程可能正在关闭同一个文件。因此需要同步多个线程的操作,并确保...
  • SWT线程开发,如果使用一个线程去访问另一个线程,则需要使用到Display对象的asyncExce方法,或者syncExce方法;在关闭前台窗口时,需要将后台工作停止。由于是多线程,前台窗口关闭后,后台...
  • 关于Activity被销毁时,如何关闭线程

    千次阅读 2018-08-11 00:12:45
    Android的activity,如果activity被销毁了,...另一种是设置开关变量,相应的生命周期,即onDestroy()把这变量改变状态 第一步:定义全局的 private boolean stopThread = false; 第二步:onDestr...
  • 守护线程 Java 的线程分为两种,一种是用户线程,另一种是守护线程 用户线程: 平时的线程 ...同时我们也可以使用 isDaemon() 方法来查看一个线程是否是守护线程。 【示例】 守护线程示例 public class
  • 取消线程

    2019-09-04 13:35:37
    另一个示例是完成由许多线程执行的任务。其中的某个线程可能最终完成了该任务,而其它线程还继续运行。由于正在运行的线程此时没有任何用处,因此取消这个线程。 取消点 仅当取消操作安全时才应取消线程。...
  • 大概思路:写两个程序,一个负责重启的程序,一个是待重启的程序,这里为了区分我们假设负责重启的那个程序叫A,待重启的程序叫B,他们都是线程,还要搭配数据库,他是两个程序的桥梁,通过设置信号量进行判断程序...
  • Java SWT线程

    2017-11-14 13:35:00
    SWT的线程开发,基本思路是:将前台和后台分开为两个类;...SWT线程开发,如果使用一个线程去访问另一个线程,则需要使用到Display对象的asyncExce方法,或者syncExce方法; 在关闭前台窗口时,需要将...
  • Java - 线程同步

    2017-07-17 18:44:11
    例如,如果多个线程尝试同一个文件写入,那么它们可能会损坏数据,因为其中一个线程可以覆盖数据,或者当一个线程打开同一个文件时,另一个线程可能会关闭相同的文件。 原文地址: ...
  • QT实现多线程

    2021-02-28 10:33:12
    案例:LED跳数字的同时,另一个线程在做sleep(也可以是任何)操作,俩线程互不影响。 线程结束后发送一个信号让主线程知道次线程结束了,然后将led暂停,并关闭线程。 一、需要新建一个类MyThread 继承于QThread ...
  • MFC的窗口并不支持多线程的控制,因此...1.我曾经试图主线程创建一个对话框,然后启动另一个线程线程完成后关闭该对话框,结果某些时候会出现奇怪的错误。因此,不要多个线程对同一个窗口操作。 2. 不
  • 任何代码都可能抛出RuntimeException,所以每当调用另一个方法时,都要对它的行为保持怀疑 两种方式处理可能的非正常线程终止情况 (1) 把任务套try块,如果抛出异常先通知一下框架该线程已经终结 线程池和...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 264
精华内容 105
关键字:

在一个线程中关闭另一个线程