精华内容
下载资源
问答
  • 2019-01-22 16:54:38

    winform 多线程中ShowDialog()步骤无效的解决办法

    前言

    比如如下代码

    private void Form1_Load(object sender, EventArgs e){    
    	Thread thread = new Thread(Test);    
    	thread.IsBackground = true;    
    	thread.Start();
    }
    private void Test(){    
    	Form2 form2 = new Form2();    
    	form2.ShowDialog();
    }
    

    form2的ShowDialog()显示并不是模式窗体,如何解决这种情况???

    解决方案

    线程中ShowDialogowner会变成null,需要重新指定

    Form2 form2 = new Form2(); form2.ShowDialog(this);
    

    直接上面那样调用会出现问题,从不是创建某个控件的线程的其他线程调用该控件是不安全的,
    非UI线程访问控件需要使用委托。

    对 Windows 窗体控件进行线程安全调用,查询控件的 InvokeRequired 属性。

    1. 如果 InvokeRequired 返回 true,则使用实际调用控件的委托来调用 Invoke。
    2. 如果 InvokeRequired 返回 false,则直接调用控件。

    Form2增加xShowDialog成员函数,如下

    public delegate DialogResult InvokeDelegate(Form parent);
    public DialogResult xShowDialog(Form parent)
     {
         if (parent.InvokeRequired)
         {
             InvokeDelegate xShow = new InvokeDelegate(xShowDialog);
             parent.Invoke(xShow, new object[] { parent });
             return DialogResult;
         }
    
         return this.ShowDialog(parent);
     }
    

    在Form1类中这样调用:

    Form2 form2 = new Form2();
    form2.xShowDialog(this);
    
    
    更多相关内容
  • 多线程中,有时候使用MessageBox.Show方法弹出对话框,弹出的Messagebox不是模态的,不能满足我的要求.所以有了这段代码.
  • 解决多线程log4j日志输出混乱的问题,每个线程输出独立的日志最近项目中遇到一个问题:多线程场景批量执行任务的时候,所有任务的日志输出到同一个文件中,非常的混乱,根本没有办法查看任务运行情况。由此衍生出新...

    解决多线程log4j日志输出混乱的问题,每个线程输出独立的日志

    最近项目中遇到一个问题:多线程场景批量执行任务的时候,所有任务的日志输出到同一个文件中,非常的混乱,根本没有办法查看任务运行情况。

    由此衍生出新的需求:多线程场景下实现每个线程日志独立输出。因为任务运行时可能会有数百个任务同时执行,所以不能采用传统的log4j配置文件解决。

    解决思路:调用log4j的源码,创建新的实现了log4j接口的类,为每个线程创建logger实例,根据logger实例以变量形式动态设置输出文件。

    解决过程:

    通过log4j日志文件可以知道,appender主要控制日志输出到什么地方(控制台、文件),layout主要控制日志打印格式。查看org.apache.log4j.RollingFileAppender的源码了解到,构造实例时需要传入layout,filename,datepattern。



    创建继承了DailyRollingFileAppender类的ThreadFileAppender类,传入指定的layout,filename,datepattern调用父类的构造函数构建appender对象。


    解决了关键的问题点之后,封装一个静态方法返回logger实例,以供业务系统调用。

    关键代码如下:

    ThreadLogger.java封装了实现代码。

    package com.niukl.log4j;
    
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import org.apache.log4j.DailyRollingFileAppender;
    import org.apache.log4j.Layout;
    import org.apache.log4j.Level;
    import org.apache.log4j.Logger;
    import org.apache.log4j.PatternLayout;
    
    public class ThreadLogger {
    
    	public static Logger getLogger(String logName) {
    		Logger logger = null;
    
    		logger = Logger.getLogger(logName);
    		PatternLayout layout = new PatternLayout("[%d{MM-dd HH:mm:ss}] %-5p %-8t %m%n");
    
    		// 日志文件按照每天分文件夹存放
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    		String logPath = "D://logs/log4jTest/" + sdf.format(new Date()) + "/";
    
    		// 文件输出
    		ThreadLogger.ThreadFileAppender fileAppender = null;
    
    		try {
    			fileAppender = new ThreadFileAppender(layout, logPath, logName, "yyyy-MM-dd");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		fileAppender.setAppend(false);
    		fileAppender.setImmediateFlush(true);
    		fileAppender.setThreshold(Level.DEBUG);
    
    		// 绑定到logger
    		logger.setLevel(Level.DEBUG);
    		logger.addAppender(fileAppender);
    
    		return logger;
    	}
    
    	/*
    	 * 继承了log4j类的内部类
    	 */
    	public static class ThreadFileAppender extends DailyRollingFileAppender {
    		public ThreadFileAppender(Layout layout, String filePath, String fileName, String datePattern)
    				throws IOException {
    			super(layout, filePath + fileName + ".log", datePattern);
    		}
    	}
    }
    


    MyThread.java是用于执行任务线程的业务类:

    package com.niukl.log4j;
    
    import org.apache.log4j.Logger;
    
    public class MyThread implements Runnable {
    
    	String logName;
    
    	public MyThread(String logName) {
    		this.logName = logName;
    	}
    
    	public void run() {
    
    		// 在run方法内实现线程独立的logger实例
    		Logger logger = ThreadLogger.getLogger(logName);
    
    		logger.info(logName + "_" + Thread.currentThread().getName() + " started!");
    
    		logger.error("this is error!");
    
    		logger.info(logName + "_" + Thread.currentThread().getName() + " finished!");
    	}
    }


    TestLog.java用于管理线程:

    package com.niukl.log4j;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import org.apache.log4j.Logger;
    
    public class TestLog {
    
    	// 这是主线程的Logger,这些不需独立日志的类也可以创建为普通的Logger,通过log4j配置文件配置参数
    	static Logger logger = ThreadLogger.getLogger("main_log");
    
    	public static void main(String[] args) {
    
    		try {
    			ExecutorService executor = Executors.newCachedThreadPool();
    			logger.info("任务开始执行");
    
    			for (int i = 0; i < 200; i++) {
    				MyThread thread = new MyThread(String.valueOf(i));
    
    				executor.submit(thread);
    			}
    			executor.shutdown();
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		logger.info("任务结束!");
    
    	}
    }
    



    运行效果:

    每个线程打印的日志都是独立的,由于任务需要周期性执行,所以采取以天为单位分文件夹存放。



    ps:程序中引用的log4j的jar包是log4j-1.2.16.jar


    展开全文
  • Java多线程

    千次阅读 2021-02-28 06:03:31
    多线程应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的1、进程直译:正在进行中的程序一个程序就是一个进程,而一个程序中的多个任务则被称为线程,进程其实就是一个静态的概念2、线程(控制单元/...

    多线程

    应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的

    1、进程

    直译:正在进行中的程序

    一个程序就是一个进程,而一个程序中的多个任务则被称为线程,进程其实就是一个静态的概念

    2、线程(控制单元/执行路径)

    就是进程中一个负责程序执行的控制单元(执行路径)

    一个线程中可以执行多个路径,称之为多线程

    一个进程中至少有一个线程

    开启多线程是为了同时运行多部分代码,每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务

    3、多线程存在的利弊

    多线程的好处:解决了多部分同时运行的问题

    多线程的弊端:线程太多会使运行效率的降低

    4、JVM中的多线程解析

    JVM虚拟机的启动时本身就是多线程,至少有两个可以分析出来

    执行main函数的线程

    该线程的任务代码都定义在main函数中

    负责垃圾回收的线程

    该线程的任务代码都在垃圾回收器中

    垃圾回收器实际上就是垃圾回收程序,可以通过系统System类中中的gc()方法唤醒调用

    class Demo extends Object{

    public void finalize(){

    System.out.println("demo ok");

    }

    }

    class ThreadDemo{

    public static void main(){

    new Demo();

    new Demo();

    System.gc();

    new Demo();

    System.out.println("hello zimo!");

    }

    }

    // >: hello zimo!

    // >: demo ok

    // >: demo ok

    5、创建线程

    创建线程的目的是为了开启一条执行路径,去运行指定的代码和其他代码实现同时运行,运行的指定代码就是这个执行路径的任务。

    所以开启线程是为了运行指定代码,只有继承Thread类,并复写run方法,将运行的代码定义在run方法中即可。

    jvm创建的主线程的任务都定义在了主函数中,而自定义的线程任务运行在哪?

    ​ Thread类用于描述线程,线程是需要任务的,所以Thread类也有对任务的描述。这个任务就是通过Thread类中的run方法来体现。也就是说,run方法就是封装自定义线程运行任务的函数。

    ​ run方法就是定义在线程要运行的任务代码。

    1、创建线程方式一:继承Thread类

    定义一个类继承Thread类

    覆盖Thread类中的run方法

    直接创建Thread的子类对象创建线程

    调用start方法开启线程并调用线程的任务run方法执行

    多线程实现两个对象同时运行实例:

    class Demo extends Thread{

    private String name;

    Demo(String name){

    // super(name); // 给线程起个名

    this.name = name;

    }

    public run(){

    show();

    }

    public void show(){

    for(int i = 0; i < 20; i++){

    System.out.println(name + "....." + i + getName());

    }

    }

    }

    class ThreadDemo{

    public static void main(){

    Demo d1 = new Demo("zimo");

    Demo d2 = new Demo("mozi");

    // d1.run();

    // d2.run();

    d1.start(); // 开启线程,调用run方法

    d2.start();

    System.out.println("hello zimo!");

    }

    }

    可以通过Thread的getName()获取线程的名称 Thread - 编号(从0开始)

    获取当前运行线程名称 Thread.currentThread().getName() 获取线程名称

    主线程的名称:main

    2、创建线程方式二:实现Runnable接口

    定义类实现Runnable接口

    覆盖接口中的run()方法,将线程的任务代码封装到run()方法中

    通过Thread类创建线程对象,并将Runnable接口的子类对象作为构造函数的参数进行传递

    因为线程的任务都封装在Runnable接口子类对象的run()方法中,所以要在线程对象创建时就必须明确要运行的任务

    调用线程对象的start()方法开启线程

    如果该类已经继承了一个父类,想扩展功能为多线程,可以通过接口的形式完成

    它的出现仅仅是将线程的任务进行了对象的封装

    class Demo extends FuDemo implements Runnable{

    private String name;

    Demo(String name){

    // super(name); // 给线程起个名

    this.name = name;

    }

    // 覆盖接口中的run方法

    public void run(){

    show();

    }

    public void show(){

    for(int i = 0; i < 20; i++){

    System.out.println(name + "....." + i + getName());

    }

    }

    }

    class ThreadDemo{

    public static void main(){

    Demo d = new Demo();

    Thread t1 = new Thread(d);

    Thread t2 = new Thread(d);

    t1.start(); // 开启线程,调用run方法

    t2.start();

    System.out.println("hello zimo!");

    }

    }

    实现Runnable接口的好处:

    将线程的任务从线程的子类中分离出来,进行了单独的封装

    按照面向对象的思想将任务封装成了对象

    避免Java单继承的局限性,所以第二种常用

    6、线程的四种状态

    CPU的执行资格:可以被CPU处理到,在处理的队列中排队

    CPU的执行权:正在被CPU进行处理

    63d0196732e6

    线程的四种状态.png

    sleep方法需要指定睡眠时间,单位是毫秒。

    一个特殊的状态:就绪。具备了执行资格,但是还没有获取资源

    多线程示例:卖票

    class Ticket extends Thread{

    private static int num = 100; // 如果不用静态的 他就会每个线程有独立的100张票

    public void run(){

    while(num > 0){

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    }

    class Ticket1 implements Runnable{

    private int num = 100;

    public void run(){

    while(num > 0){

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    }

    class TicketDemo{

    public static void main(String[] args){

    Ticket t1 = new Ticket();

    Ticket t2 = new Ticket();

    Ticket t3 = new Ticket();

    Ticket t4 = new Ticket();

    t1.start();

    // t1.start(); // 多次启动会抛出异常

    t2.start();

    t3.start();

    t4.start();

    Ticket1 t = new Ticket1(); // 创建一个线程任务对象

    Ticket1 tt1 = new Ticket1(t);

    Ticket1 tt2 = new Ticket1(t);

    Ticket1 tt3 = new Ticket1(t);

    Ticket1 tt4 = new Ticket1(t);

    tt1.start();

    tt2.start();

    tt3.start();

    tt4.start();

    }

    }

    63d0196732e6

    多线程卖票内存分析图.png

    7、线程安全问题

    导致产生线程安全的原因:

    多个线程在操作共享的数据

    操作共享数据的线程代码有多条

    当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算

    解决方法:

    Java中使用同步代码块:synchronized(对象){需要被同步的代码块}

    同步函数:pubilc synchronized void add(int num){}

    同步锁使用前提:同步中必须有多个线程,并且使用同一个锁。

    同步的好处:解决了安全问题>;

    同步的弊端:相对降低了效利,因为同步外的线程都会判断同步锁

    class Ticket implements Runnable{

    private int num = 100;

    Object obj = new Object();

    public void run(){

    // Object obj = new Object(); //假设所在方法里,每个线程都有自己单独的锁,那么还是存在问题

    while(num > 0){

    synchronized(obj){

    // synchronized(new Object()){ // err 相当于一个线程有一个独立的对象

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    }

    }

    class TicketDemo{

    public static void main(String[] args){

    Ticket t = new Ticket(); // 创建一个线程任务对象

    Ticket tt1 = new Ticket(t);

    Ticket tt2 = new Ticket(t);

    Ticket tt3 = new Ticket(t);

    Ticket tt4 = new Ticket(t);

    tt1.start();

    tt2.start();

    tt3.start();

    tt4.start();

    }

    }

    8、线程同步函数示例

    // 需求:两个储户,每个都到同一家银行,每次100,共三次

    class Bank{

    private int sumMoney;

    // private Object obj = new Object();

    public synchronized void add(int money){ // 同步函数

    // synchronized(obj){

    sum += sum;

    try {Thread.sleep(10);}catch(InterruptedException e){}

    System.out.println("sum = " + sum);

    // }

    }

    }

    class Cus implements Runnable{

    private Bank b = new Bank();

    for(int i = 0; i < 3; i++){

    b.add(100);

    }

    }

    class CusBankDemo{

    public static void main(String[] args){

    Cus c = new Cus();

    Thread t1 = new Thread(c);

    Thread t2 = new Thread(c);

    t1.start()

    }

    }

    验证同步函数的锁

    同步函数锁使用的是this对象

    class Ticket implements Runnable{

    private int num = 100;

    // Object obj = new Object();

    public void run(){

    if(flag){

    while(true){

    // synchronized(obj){ // 如果是obj,那么线程代码块和线程函数的锁不是同意把,还是存在安全问题

    synchronized(this){

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

    if(num > 0){

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    }

    }else

    while(true)

    show();

    }

    public synchronized void show(){

    // public static synchronized void show(){ // 静态代码块没有this对象,只有一个getClass获取的当前class字节码所属的对象

    // 同步代码块可以通过传synchronized(this.getClass()){}来实现同步

    // 获取字节码文件对象还可以通过类型.class: Ticket.class

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    class TicketDemo{

    public static void main(String[] args){

    Ticket t = new Ticket(); // 创建一个线程任务对象

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

    Ticket tt1 = new Ticket(t);

    Ticket tt2 = new Ticket(t);

    tt1.start();

    tt2.start();

    }

    }

    同步函数和同步代码块的区别是:

    同步函数的锁是固定的this

    同步代码块的锁是任意的对象

    静态的同步函数使用的锁是,该函数所属字节码文件,该同步锁对象不是this

    可以通过getClass()方法获取,也可以用当前类名.class表示

    建议使用同步代码块

    9、多线程下的单例模式

    饿汉式(单例模式)

    class Single{

    private static final Single s = new Single(); // 1.固定不变,一开始就被创建

    private Single(){}

    public static Single getInstance(){

    return s; // 2.返回地址,不存在线程安全问题

    }

    }

    懒汉式(延迟加载单例模式)

    class Single{

    private static final Single s = null; // 共享数据

    private Single(){}

    public static Single getInstance(){

    // 方法一:虽然解决了问题,但是每次进来都要判断锁,效率低

    // public static synchronized Single getInstance(){

    // 方法二:同步代码块,这样写还是和同步方法没区别,一进来就要判断锁

    synchronized(Single.class){ // 这边不能使用getClass()方法,是非静态的

    if(s == null){

    // 可能存在线程切换同时进入这里

    s = new Single(); // 产生多个对象,不能保证唯一性

    }

    }

    return s;

    }

    // 改良,通过双重判断解决懒汉式的 线程安全问题 和 效率问题

    public static Single getInstance(){

    if(s == null){

    synchronized(Single.class){

    if(s == null){

    s = new Single();

    }

    }

    }

    return s;

    }

    }

    10、死锁示例

    死锁:常见的情景之一:同步的嵌套

    class Ticket implements Runnable{

    private int num = 100;

    private boolean flag = true;

    Object obj = new Object();

    public void run(){

    if(flag){

    while(true){

    synchronized(obj){ // obj -->> this

    show();

    }

    }

    }else

    while(true)

    show();

    }

    public synchronized void show(){ // this -->> obj

    synchronized(obj){

    System.out.println(Thread.currentThread().getName() + "..sale.."+num--);

    }

    }

    }

    class DeadLockDemo{

    public static void main(String[] args){

    Ticket t = new Ticket(); // 创建一个线程任务对象

    Ticket t1 = new Ticket(t);

    Ticket t2 = new Ticket(t);

    t.flag = false;

    t1.start();

    t2.start();

    }

    }

    手动实现死锁示例:遵循原则--嵌套

    class Test implements Runnable{

    private boolean flag;

    Test(boolean flag){

    this.flag = flag;

    }

    public void run{

    if(flag){

    synchronized(MyLock.locka){

    system.out.println("if-locka");

    synchronized(MyLock.lockb){

    system.out.println("if-lockb");

    }

    }

    }else{

    synchronized(MyLock.lockb){

    system.out.println("else-locka");

    synchronized(MyLock.locka){

    system.out.println("else-lockb");

    }

    }

    }

    }

    }

    class MyLock{

    public static final Object locka = new Object();

    public static final Object lockb = new Object();

    }

    class DeadLockTest{

    public static void main(String[] args){

    Test a = new Test(true);

    Test b = new Test(false);

    Thread t1 = new Thread(a);

    Thread t2 = new Thread(b);

    t1.start();

    t2.start();

    System.out.println("hello zimo!");

    }

    }

    展开全文
  • C#多线程解决界面卡死问题的完美解决方案
  • 多线程SFML + ImGui Mandelbrot 使用SFML + ImGui的多线程C ++ Mandelbrot渲染器。 用法 DESCRIPTION A multi-threaded C++ Mandelbrot renderer using SFML + ImGui. SYNOPSIS mandelbrot [-h] [-v|-vv] [-f] [-...
  • 在大漠多线程模板中,脚本副线程的作用主要是一个监控线程,可以监控游戏窗口是否存在,游戏是否卡屏,是否掉线,当然你可以用来进行游戏里的其他检测监控。 511遇见易语言多线程大漠多线程 大漠多线程主副线程 ...

    在大漠多线程模板中,脚本副线程的作用主要是一个监控线程,可以监控游戏窗口是否存在,游戏是否卡屏,是否掉线,当然你可以用来进行游戏里的其他检测监控。

    511遇见易语言多线程大漠多线程

    大漠多线程主副线程

    .版本 2
     
    .子程序 脚本副线程, , , 监控线程
    .参数 序号, 整数型
    .局部变量 dm, dmsoft
    .局部变量 dm_ret, 整数型
    .局部变量 死循环, 逻辑型
    .局部变量 任务完成, 文本型
     
    ' 要把大漠插件接口初始化为MAT线程模型
    CoInitializeEx (0, 0)
    线程信息 [序号].线程状态 = #线程状态_正在运行
     
    多线程_异步通知UI (#通知类型_更新, 序号)
    ' 创建对象
    线程信息 [序号].dm.创建 ()
    dm = 线程信息 [序号].dm
     
    .如果真 (dm.Ver () = “”)
        日志输出 (“大漠对象创建失败”)
        设置异常 (序号, “对象创建失败”)
     
        返回 ()
    .如果真结束
     
    ' 开启全局字库
    ' dm.EnableShareDict ()
    ' 设置全局路径
    dm.SetPath (“c:\test”)
    ' 开始绑定游戏窗口,根据自己的游戏换绑定方式
    dm_ret = dm.BindWindowEx (线程信息 [序号].窗口句柄, “normal”, “normal”, “dx”, “dx.public.anti.api|dx.public.disable.window.show”, 0)
    .如果真 (dm_ret ≠ 1)
        日志输出 (“主:绑定失败,错误码:” + 到文本 (dm.GetLastError ()))
        ' 通知主线程进行结束操作(释放资源)
        设置异常 (序号, “绑定失败:副”)
        返回 ()
    .如果真结束
     
    死循环 = 真
    .判断循环首 (死循环)
        ' 可用来检测脚本的异常情况,比如,掉线,目标窗口关闭,
        检测异常 (序号)
        脚本延时 (序号, 1000)
     
    .判断循环尾 ()
     
     
    .子程序 做任务
    .参数 序号
    .局部变量 dm, dmsoft
     
    dm = 线程信息 [序号].dm
    dm.KeyPressChar (“D”)
    脚本延时 (序号, 1000)
     
     
    .子程序 脚本延时
    .参数 序号
    .参数 时间
     
    延时 (时间)

    源码:易语言多线程大漠多线程-37大漠多线程模板-7脚本主副线程

    展开全文
  • opencv多线程显示的问题和解决方法

    千次阅读 2020-04-18 11:36:23
    opencv多线程显示的问题和解决方法 1.问题描述 由于业务需求,需要在多线程中,使用OpenCV读取图片并显示,实现很简单,只需要调用python的threading创建线程,并在线程中显示图片即可,但会出现一个问题: 只能显示第...
  • C#高级--多线程详解

    千次阅读 多人点赞 2021-10-03 16:05:41
    C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时,它就是一个进程,进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是...
  • 架构师:『试试使用多线程优化』 第二天 头发很多的程序员:『师父,我已经使用了多线程,为什么接口还变慢了?』 架构师:『去给我买杯咖啡,我写篇文章告诉你』 ……吭哧吭哧买咖啡去了 在实际工作中,错误...
  • 多线程,我们更多是用来让不同的线程做相同的事情,如果让不同的线程执行不同的任务,并且每个线程任务的数量也不一样,还可以自由的添加任何数量的任务,那么下面的教程解决了这个问题,包括多线程分配单个不同的...
  • 爬虫 第五讲 多线程爬虫

    万次阅读 2021-04-29 15:30:00
    爬虫 第五讲 多线程爬虫 一、多线程 1.多线程基本介绍 有很多的场景中的事情是同时进行的,比如开车的时候 手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的。 程序中模拟多任务 import time def sing(): for ...
  • Java多线程游戏仿真实例分享

    万次阅读 多人点赞 2021-02-02 18:20:57
    多线程的创建、多线程的应用、多线程的特点以及多线程的注意事项) 2、如何让小球在画面中真实地动起来?(赋予小球匀速直线、自由落体、上抛等向量运动) 3、多线程游戏仿真实例分享(飞机大战、接豆人、双线挑战...
  • Java多线程API调用并接受处理结果

    千次阅读 2020-04-10 11:08:39
    最近一直学习多线程知识苦于没有机会运用到实际项目中,不过今天接到一个需求:请求发送多个第三方api请求,组合这些请求的返回结果返回给前端调用。如果说写for循环,单个请求结束后再继续调用下一个请求(自己...
  • java课程设计-多人聊天工具(socket+多线程

    千次阅读 多人点赞 2021-08-23 20:40:09
    //VERTICAL_SCROLLBAR_AS_NEEDED设置垂直滚动条需要时出现 //HORIZONTAL_SCROLLBAR_NEVER设置水平滚动条不出现 //创建信息显示区的画布并添加到show_area JScrollPane panel = new JScrollPane(show_area,...
  • Qt 的4种多线程实现详解

    千次阅读 2021-02-08 19:25:53
    为何需要多线程? 1、进行耗时操作时,可以处理用户的其他输入输出。比如,如果在UI线程里面进行耗时操作,界面会不响应用户操作。 2、提升程序性能。现在的电脑一般都是多核CPU,多线程并行处理事务,可以大大...
  • C#多线程编程总结

    千次阅读 多人点赞 2020-07-20 11:26:36
    一个最直接的方法便是使用多线程多线程编程的方式在WinForm开发中必不可少。 本文介绍在WinForm开发中如何使用多线程,以及在线程中如何通过Control.Invoke方法返回窗体主线程执行相关操作。 -. WinForm多线程...
  • python多线程结束线程Python threading module is used to implement multithreading in python programs. In this lesson, we will study about Thread and different functions of python threading module. ...
  • Python多线程(自学必备 超详细)

    万次阅读 2021-06-06 00:21:42
    多线程技术 多任务 1.1 多任务的概念 多任务:在同一时间内执行多个任务[可以把每个任务理解为生活当中的每个活] 1.2 现实生活中的多任务 操作系统可以同时运行多个任务。比如,你一边打游戏,一边和队友沟通,这...
  • QT多线程编程详解

    万次阅读 多人点赞 2019-04-24 22:08:20
    一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程,即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程,不能工作在次...二、QT多线程简介 QT通过三种形式提供了对线程...
  • Java面试题超详细整理《多线程篇》

    千次阅读 2021-08-05 13:06:04
    而进行拆分时可以使用多线程技术来完成。 优点:提高了程序的执行效率,一定情况下可以提高程序运行速度。 缺点:可能出现内存泄漏、上下文切换、线程安全、死锁等问题。 并发编程三要素是什么? 原子性:一个...
  • QSerialport多线程方法

    千次阅读 2019-05-20 07:19:42
    QSerialport多线程方法 使用Qt也已经有一段时间了,虽然使用过继承QThread重写run函数,以及继承QObject然后使用MoveToThread两种方法实现多线程,但是在QSerialPort的使用过程中,两种方法都存在一定的问题。 ...
  • PyQt5——多线程

    千次阅读 2019-09-26 15:22:19
    多线程 多线程技术设计三种方法,其中一种是使用计数器模块QTimer,一种是使用多线程模块QThread,还有一种使用事件处理的功能。 QTimer 如果要在应用程序汇总周期性地进行某项操作,比如周期性地检测主机的CPU,则...
  • wxpython多线程

    千次阅读 2019-05-21 15:52:10
    例如python3多线程threading功能强大,结合jion()和setDaemon()函数使用更灵活,使用多线程时首先想到了threading, 但wxpython是用python写的一个UI框架,其本身自带有多线程函数: wx.PostEvent wx.CallAfter wx....
  • Android 多线程编程

    千次阅读 2021-12-05 17:39:45
    Android 的多线程编程与 Java 多线程编程基本是使用相同的语法,比如定义一个线程只需要新建一个类继承自 Thread,重写父类的 run() 方法 class MyThread : Thread() { override fun run() { // 编写具体的逻辑 }...
  • 之前也有看到别的小伙伴使用PyQt5中的QThread来写多线程,或许自己比较愚钝,不是很理解,于是按照常规写多线程的方法,即直接传入函数,启动多线程,传入参数。 问题描述: 编写的上位机程序中,当触发界面上的...
  • Java多线程实现TCP网络Socket编程(C/S通信)

    万次阅读 多人点赞 2020-10-26 09:45:38
    本篇详细记录实现java多线程通信,目标达到客户端可以一次接收服务器发送的多条信息,避免阻塞。将客户端接收信息功能独立为一个线程来完成,进一步完善TCP的Socket网络通信,C/S软件架构的程序设计!
  • Linux gdb调试三(多线程

    千次阅读 2022-03-09 15:25:59
    } [点击并拖拽以移动] ​ 代码不做分析 二、调试 主要目的熟悉多线程: GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.5) 7.11.1 Copyright (C) 2016 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or ...
  • 易语言大漠多线程模板脚本主线程

    千次阅读 2020-06-01 09:10:55
    511遇见易语言多线程大漠多线程 大漠多线程模板脚本主线程源码 .版本 2 .支持库 EThread .子程序 脚本主线程, , , 游戏的动作逻辑都在这里 .参数 序号, 整数型 .局部变量 dm, dmsoft .局部变量 dm_ret, 整数型 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 187,334
精华内容 74,933
关键字:

多线程show