精华内容
下载资源
问答
  • QT (启动一个线程)

    万次阅读 2018-12-01 17:06:47
    启动一个线程的步骤: (1) 创建一个自己的线程类继承QT中的QThread类 创建线程类WorkThread; (2) 在自己的WorkThreak类中重新实现run()函数, 该函数是一个死循环, 主要是完成自己需要的功能代码 (3) 使用自己的类...


    启动一个线程的步骤:
    (1)  创建一个自己的线程类继承QT中的QThread类   创建线程类WorkThread;
    (2)   在自己的WorkThreak类中重新实现run()函数, 该函数是一个死循环, 主要是完成自己需要的功能代码
    (3)  使用自己的类WorkThread 实例一个对象,也就是用该类创建一个变量 如: WorkThread *task = new WorkThread (this);
    (4)  然后通过start()函数启动这个线程, 如task->start();启动该线程
    重载的run()函数就是一个独立运行线程, 要想实现多线程就多次继承QThread类在不同的类中的run()函数中实现不同的功能

    当然不止只重载 run() 函数, 可以重载 start() 函数为一个槽函数,使用按钮启动该线程或者连接某个信号启动该线程

    实现如下

    例子1

    (1) 创建类WorkThread继承QThread类; 

    WorkThread.h文件:

    #ifndef WORKTHREAD_H
    #define WORKTHREAD_H
    #include <QThread>
    
    class WorkThread : public QThread
    {
    public:
        WorkThread();
    private:
        virtual void run();//任务处理线程
    public:
        int workCount;//计数
    
    signals:
    
    public slots:
    
    };
    #endif // WORKTHREAD_H

    WorkThread.cpp文件:

    #include "WorkThread.h"
    #include <QDebug>
    
    
    WorkThread::WorkThread()
    {
        workCount = 0;
    }
    
    //(2) run()重新实现
    void WorkThread::run()
    {
        while(true)
        {
            workCount++;
            if(workCount>=1000) workCount=0;
            qDebug()<<"WorkThread"<<workCount;
            sleep(1);//线程 睡眠一秒一次
        }
    }
    

    main.cpp文件:

    #include <QCoreApplication> //不创建GUI界面
    #include <QDebug>
    #include "WorkThread.h"
    
    int main(int argc,char** argv)
    {
        QCoreApplication app(argc,argv);
    
        WorkThread *task = new WorkThread; // (3) 创建一个 WorkThread 对象
        qDebug()<<"线程测试开始:";
        task->start();//启动该线程 (4)
        qDebug()<<"线程测试结束:";
    
        return app.exec();
    }
    

    工程管理文件 Thread.pro文件:

    HEADERS += \
        WorkThread.h
    
    SOURCES += \
        WorkThread.cpp \
        main.cpp
    

    工程目录;

    程序运行状态:

    测试上面的线程使用

    task->quit();
    task->wait(); 
    

    线程也不会终止, 开启的新线程是死循环啊

     

    例子2

    工程文件:

    1. 主要想法就是在子线程中的循环设定一个条件,当想停止这个线程时,就改变线程循环的条件

    如:  while(isStop==false)  只需要改变  "isStop " 的状态就可以实现线程的循环了

    2. 实现一个修改这个标志的函数,方便外部修改

    mythread.cpp文件:

    #include "mythread.h"
    #include <QThread>
    #include <QDebug>
    myThread::myThread(QObject *parent) : QObject(parent)
    {
        isStop=false;
    }
    
    
    void myThread::myTimeout()
    {
        while(isStop==false)
        {
            QThread::sleep(1);
            emit mySignal();
            qDebug()<<"子线程号:"<<QThread::currentThread();
    
            if(true==isStop)
            {
                break;
            }
        }
    }
    
    //修改线程工作标志的,公共函数
    void myThread::setFlag(bool flag)
    {
        isStop=flag;
    }
    

    mythread.h文件

    #ifndef MYTHREAD_H
    #define MYTHREAD_H
    
    #include <QObject>
    
    class myThread : public QObject
    {
        Q_OBJECT
    public:
        explicit myThread(QObject *parent = nullptr);
    
        void myTimeout();//线程处理函数, 也就是实际开启的线程
        void setFlag(bool flag=true);//设置线程中标志,用于停止线程
    
    signals:
        void mySignal(); //定义一个信号,在该子线程中每秒发射一次该信号
    
    private:
        bool isStop;//线程工作标志
    
    public slots:
    };
    
    #endif // MYTHREAD_H
    

     

    3. 在外部只要调用这个修改标志的公共函数,同时调用 task->quit();task->wait(); 共同终止一个线程  

    widget.cpp文件:

    #include "widget.h"
    #include "ui_widget.h"
    #include <QDebug>
    
    
    Widget::Widget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::Widget)
    {
        ui->setupUi(this);
    
        //动态分配空间, 不能指定父对象
        myT = new myThread;//指定父对象后下面不可以在加入子线程中,下面的子线程相当于其父对象
    
        thread = new QThread(this);//创建子线程
    
        myT->moveToThread(thread);//把自定义的线程加入到子线程中
    
        connect(myT,&myThread::mySignal,this,&Widget::dealSignal);
    
        qDebug()<<"主线程号:"<<QThread::currentThread();//打印主线程号
    
        connect(this,&Widget::startThread,myT,&myThread::myTimeout);
    
        connect(this,&Widget::destroyed,this,&Widget::deadClose);//右上角"X"关了窗口线程还在运行
    
        //线程处理函数内部,不允许操作图形界面
        //connect()第五个参数的作用,连接方式 默认 队列 直接
        //多线程才有意义
    }
    
    Widget::~Widget()
    {
        delete ui;
    }
    
    //对话框右上角的 叉号 关闭事件触发的槽函数
    void Widget::deadClose()
    {
        on_buttonStop_clicked();//停止线程
        delete myT;     //释放线程空间
    }
    
    //子线程信号触发的主线程中的槽函数
    void Widget::dealSignal()
    {
        static int i=0;
        i++;
        ui->lcdNumber->display(i);
    }
    
    //start按钮触发槽函数
    void Widget::on_buttonStart_clicked()
    {
        if(thread->isRunning()==true)
        {
            return;
        }
    
        thread->start();//启动线程,但是没有启动线程处理函数
        myT->setFlag(false);//修改线程标志后才真启动了线程
    
        //不能直接调用线程处理函数
       // myT->myTimeout();//直接调用,导致,线程处理函数和主线程是在同一线程
    
        //只能通过signal-slot方式调用
        emit startThread();
    
    }
    
    //stop按钮触发槽函数
    void Widget::on_buttonStop_clicked()
    {
        if(thread->isRunning()==false)
        {
            return ;
        }
        myT->setFlag(true);
        thread->quit();
        thread->wait();
    }
    

    widget.h文件

    #ifndef WIDGET_H
    #define WIDGET_H
    
    #include <QWidget>
    #include "mythread.h"
    #include <QThread>
    
    namespace Ui {
    class Widget;
    }
    
    class Widget : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit Widget(QWidget *parent = 0);
        ~Widget();
    
    
    private slots:
        void on_buttonStart_clicked();//槽
        void on_buttonStop_clicked(); //槽
    
        void dealSignal();  //子线程信号触发的主线程中的槽函数
        void deadClose();   //对话框右上角的 叉号 关闭事件触发的槽函数
    
    signals:
        void startThread();//启动子线程的信号
    
    private:
        Ui::Widget *ui;
    
        myThread *myT;
        QThread *thread; //定义一个线程对象指针在构造函数中分配空间
    };
    
    #endif // WIDGET_H
    

     

    main.cpp文件

    #include "widget.h"
    #include <QApplication>
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        Widget w;
        w.show();
    
        return a.exec();
    }
    

     

     

     

     

     

    展开全文
  • 启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。 ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。

    展开全文
  • 启动一个异步线程去执行一个任务

    千次阅读 2018-01-19 21:54:48
    1.业务场景: 浦发银行...银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动一个异步线程将结果查询回来. 代码编辑如下: ...

    1.业务场景:

     浦发银行充值接口,他行卡充值不是实时将充值结果返回的,需要我们自己去手动去查。银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动一个异步线程将结果查询回来.

    代码编辑如下:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
               http://www.springframework.org/schema/aop   
               http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
               http://www.springframework.org/schema/tx  
               http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
               http://www.springframework.org/schema/context  
               http://www.springframework.org/schema/context/spring-context-3.2.xsd"
        default-autowire="byName" default-lazy-init="false">
    
        <!-- 使用spring提供的线程池 -->
        <bean id="executePool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
            <!-- 线程池维护线程的最小数量 -->
            <property name="corePoolSize" value="1"></property>
            <!-- 线程池维护线程所允许的空闲时间 -->
            <property name="maxPoolSize" value="5"></property>
            <!-- 线程池所使用的最大数量 -->
            <property name="keepAliveSeconds" value="30000" />
            <!-- 线程池所使用的缓冲队列 -->
            <property name="queueCapacity" value="1000" />
        </bean>
    
        <bean id="asyExecuteService" class="com.adai.asy.service.imp.AsyExecuteServiceImp" destroy-method="destory">
            <property name="executePool"  ref="executePool" />
        </bean>
        
        <context:annotation-config/>
        <context:component-scan base-package="com.adai"/>
    </beans>
    
    package com.adai.asy.service;
    
    import java.util.Map;
    /**
     * 异步服务接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyExecuteService {
    	/**
    	 * 异步服务
    	 * @param taskId  服务id
    	 * @param sendMap 请求参数
    	 */
    	public void execute(String taskId , Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service;
    
    import java.util.Map;
    
    /**
     * 异步接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyService {
    	/**
    	 * 异步交易接口
    	 * @param sendMap 请求参数
    	 */
    	public void execute(Map<String,Object> sendMap) ;
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Date;
    import java.util.Map;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import com.adai.asy.service.AsyExecuteService;
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    import com.adai.util.Utils;
    /**
     * 异步服务实现类:这里需要注入线程池启动一个线程去执行任务
     * @author v-chenk25
     * @since 2018-01-19 21:35
     */
    public  class AsyExecuteServiceImp implements AsyExecuteService , ApplicationContextAware{
    	private ApplicationContext context ;
    	private ThreadPoolTaskExecutor executePool ;
    	public void execute(String taskId, final Map<String, Object> sendMap) {
    		sendMap.put(Dict.TASKID, taskId) ;
    		final AsyService asyService = (AsyService) this.context.getBean(taskId) ;
    		this.executePool.execute(new Runnable() {
    			public void run() {
    				asyService.execute(sendMap);
    			}
    		});
    		
    		
    	}
    	
    	public Map<String,Object> prepareReq(Map<String,Object> sendMap){
    		sendMap.put(Dict.ORDERID, Utils.getCurrentFormat(new Date(), Dict.YNRH)) ;
    		return sendMap;
    	}
    	
    	public void destory() {
    		if(this.executePool != null) {
    			this.executePool.shutdown();
    		}
    	}
    	
    	public void setApplicationContext(ApplicationContext context) throws BeansException {
    		this.context = context ;
    	}
    	public void setExecutePool(ThreadPoolTaskExecutor executePool) {
    		this.executePool = executePool;
    	}
    	
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    /**
     * 异步服务接口实现类
     * 这里主要时为了打印每一个任务需要执行的时间,正真执行业务逻辑的方法是executeInnert
     * @author v-chenk25
     *
     */
    public abstract class AsyServiceImp implements AsyService{
    	private Log log = LogFactory.getLog(AsyServiceImp.class) ;
    	public void execute(Map<String,Object> sendMap) {
    		long start = System.currentTimeMillis();
    		log.info("异步线程开始执行:"+sendMap.get(Dict.TASKID)+"任务");
    		executeInnert(sendMap) ;
    		long end = System.currentTimeMillis();
    		log.info("异步线程执行结束,任务执行时间为:"+(end-start));
    	}
    	
    	/** 真正执行业务逻辑 **/
    	public abstract void executeInnert(Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService1")
    public class MyTaskAsyServiceImp extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理 , 比如发银行的接口,调用dubbo服务
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai.constant;
    /**
     * 常量字典
     * @author v-chenk25
     *
     */
    public class Dict {
    	/**交易流水号**/
    	public static final String ORDERID = "OrderId" ;
    	/** 日期格式 **/
    	public static final String YND = "yyyyMMdd" ;
    	/**时间戳格式**/
    	public static final String YNRH = "yyyyMMdd HH:mm:ss sss" ;
    	/**时间格式**/
    	public static final String HOUR = "HH:mm:ss" ;
    	/**交易id**/
    	public static final String TASKID = "taskId" ;
    	
    }
    
    package com.adai.util;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    /**
     * 工具类
     * @author v-chenk25
     *
     */
    public class Utils {
    	
    	/**当前日期指定格式字符串**/
    	public static String getCurrentFormat(Date date ,String format) {
    		return new SimpleDateFormat(format).format(date);
    	}
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService2")
    public class MyTaskAsyServiceImp2 extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai;
    
    import java.util.HashMap;
    import java.util.Map;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.adai.asy.service.AsyExecuteService;
    
    public class TestAsy {
    	public static void main(String[] args) {
    		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"classpath:spring-activemq.xml"}) ;
    		context.start();
    		AsyExecuteService asyService = (AsyExecuteService) context.getBean("asyExecuteService") ;
    		for(int i=1 ; i<10 ;i++) {
    			Map<String,Object> sendMap = new HashMap<String,Object>() ;
    			sendMap.put(i+"", i) ;
    			asyService.execute("myTaskAsyService"+1, sendMap);
    		}
    	}
    }
    
    总结:设计思路为:使用一个线程池开启一个线程去执行一个任务,任务id就是spring bean的名字,通ApplicationContextAware 来获取spring容器的bean,然后调用execute方法执行具体的业务逻辑。为了扩展,所以要求需要异步执行的类需要现实统一的接口,也就是AsyService接口。
    展开全文
  • 如何创建和启动一个线程

    千次阅读 2015-09-02 13:05:39
     此类中有run()方法,应该注意其用法: public void run()如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。 Thread

    原文转自:http://www.tqcto.com/article/recommend/137.html

    一、定义线程 
    1、继承java.lang.Thread类。 
    此类中有个run()方法,应该注意其用法: 
    public void run()

    如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。 
    Thread 的子类应该重写该方法。

     
    2、实现java.lang.Runnable接口。 
    public  
    void run() 

    使用实现接口 Runnable 的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的 run 方法。 
    方法 run 的常规协定是,它可能执行任何所需的操作。 

    二、实例化线程 

    1、如果是扩展java.lang.Thread类的线程,则直接new即可。 

    2、如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法: 

    Java代码 
    1. Thread(Runnable target)   
    2. Thread(Runnable target, String name)   
    3. Thread(ThreadGroup group, Runnable target)   
    4. Thread(ThreadGroup group, Runnable target, String name)   
    5. Thread(ThreadGroup group, Runnable target, String name, long stackSize)   


    三、启动线程 

    在线程的Thread对象上调用start()方法,而不是run()或者别的方法。 

    在调用start()方法之前:线程处于新状态中,新状态指有一个Thread对象,但还没有一个真正的线程。 

    在调用start()方法之后:发生了一系列复杂的事情 
    启动新的执行线程(具有新的调用栈); 
    该线程从新状态转移到可运行状态; 
    当该线程获得机会执行时,其目标run()方法将运行。 

    注意:对Java来说,run()方法没有任何特别之处。像main()方法一样,它只是新线程知道调用的方法名称(和签名)。因此,在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。 


    四、例子 

    1、实现Runnable接口的多线程例子 

    Java代码 
    1. /**  
    2. * 实现Runnable接口的类  
    3.  
    4. * @author leizhimin 2008-9-13 18:12:10  
    5. */   
    6. public class DoSomething implements Runnable {   
    7.     private String name;   
    8.   
    9.     public DoSomething(String name) {   
    10.         this.name = name;   
    11.     }   
    12.   
    13.     public void run() {   
    14.         for (int i = 0; i < 5; i++) {   
    15.             for (long k = 0; k < 100000000; k++) ;   
    16.             System.out.println(name + ": " + i);   
    17.         }   
    18.     }   
    19. }  
    20.    
    21. /**  
    22. * 测试Runnable类实现的多线程程序  
    23.  
    24. * @author leizhimin 2008-9-13 18:15:02  
    25. */   
    26. public class TestRunnable {   
    27.     public static void main(String[] args) {   
    28.         DoSomething ds1 = new DoSomething("阿三");   
    29.         DoSomething ds2 = new DoSomething("李四");   
    30.   
    31.         Thread t1 = new Thread(ds1);   
    32.         Thread t2 = new Thread(ds2);   
    33.   
    34.         t1.start();   
    35.         t2.start();   
    36.     }   
    37. }  


    执行结果: 
    李四: 0 
    阿三: 0 
    李四: 1 
    阿三: 1 
    李四: 2 
    李四: 3 
    阿三: 2 
    李四: 4 
    阿三: 3 
    阿三: 4 

    Process finished with exit code 0 

    2、扩展Thread类实现的多线程例子 

    Java代码 
    1. /**  
    2. * 测试扩展Thread类实现的多线程程序  
    3.  
    4. * @author leizhimin 2008-9-13 18:22:13  
    5. */   
    6. public class TestThread extends Thread{   
    7.     public TestThread(String name) {   
    8.         super(name);   
    9.     }   
    10.   
    11.     public void run() {   
    12.         for(int i = 0;i<5;i++){   
    13.             for(long k= 0; k <100000000;k++);   
    14.             System.out.println(this.getName()+" :"+i);   
    15.         }   
    16.     }   
    17.   
    18.     public static void main(String[] args) {   
    19.         Thread t1 = new TestThread("阿三");   
    20.         Thread t2 = new TestThread("李四");   
    21.         t1.start();   
    22.         t2.start();   
    23.     }   
    24. }  


    执行结果: 
    阿三 :0 
    李四 :0 
    阿三 :1 
    李四 :1 
    阿三 :2 
    李四 :2 
    阿三 :3 
    阿三 :4 
    李四 :3 
    李四 :4 

    Process finished with exit code 0 

    对于上面的多线程程序代码来说,输出的结果是不确定的。其中的一条语句for(long k= 0; k <100000000;k++);是用来模拟一个非常耗时的操作的。 

    五、一些常见问题 

    1、线程的名字,一个运行中的线程总是有名字的,名字有两个来源,一个是虚拟机自己给的名字,一个是你自己的定的名字。在没有指定线程名字的情况下,虚拟机总会为线程指定名字,并且主线程的名字总是mian,非主线程的名字不确定。 
    2、线程都可以设置名字,也可以获取线程的名字,连主线程也不例外。 
    3、获取当前线程的对象的方法是:Thread.currentThread(); 
    4、在上面的代码中,只能保证:每个线程都将启动,每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说,调度程序不能保证其执行次序,持续时间也无法保证。 
    5、当线程目标run()方法结束时该线程完成。 
    6、一旦线程启动,它就永远不能再重新启动。只有一个新的线程可以被启动,并且只能一次。一个可运行的线程或死线程可以被重新启动。 
    7、线程的调度是JVM的一部分,在一个CPU的机器上上,实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。 
    众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。 
    8、尽管通常采用队列形式,但这是没有保障的。队列形式是指当一个线程完成“一轮”时,它移到可运行队列的尾部等待,直到它最终排队到该队列的前端为止,它才能被再次选中。事实上,我们把它称为可运行池而不是一个可运行队列,目的是帮助认识线程并不都是以某种有保障的顺序排列唱呢个一个队列的事实。 
    9、尽管我们没有无法控制线程调度程序,但可以通过别的方式来影响线程调度的方式。 


    原文转自:编程技术

    展开全文
  • 启动一个线程是用run还是start

    千次阅读 2018-08-24 15:34:53
    启动线程肯定要用start()方法。当用start()开始一个线程后,线程就进入就绪状态,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时,才...
  • 在springMVC的service实现类中另外启动一个线程处理如何完成
  • QT学习之 如何启动一个线程

    千次阅读 2016-04-28 09:35:50
    先给出相关代码,然后加以分析 //*************dialog.h**************//   #ifndef DIALOG_H ...#define MAXSIZE 5 //最大的线程数 class QDialogButtonBox; class QProgressBar; class QPushBut
  • 我们知道,我们通过调用线程的start方法启动一个线程,那么,我们可以直接调用run方法来启动一个线程吗? 先看下面一段代码:public class Test { public static void main(String[] args) { // TODO Auto-...
  • 启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。 run()方法是线程启动后要进行回调(callback)的方法。...
  • Qt学习之如何启动一个线程

    千次阅读 2011-03-09 10:52:00
    以前看过在linux下C编程的线程书籍,今天来看看Qt如何启动一个线程吧,代码就以精通Qt4编程的为例 先来给出每个文件的相关代码然后再加以分析 //*************dialog.h**************//<b
  • 启动一个线程是调用start()方法,使线程就绪状态,以后可以被jvm调度为运行状态,一个线程必须关联一些具体的执行代码,run()方法是该线程所关联的执行代码。 实现并启动线程有两种方法: 1、写一个类继承自Thread类...
  • MainTest类中可以控制线程的暂停或继续运行... * 这个线程操作另一个线程的暂停或开始 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Thread1 th1 = new T
  • java同时启动个线程

    千次阅读 2019-03-11 14:59:51
    当我们需要同时启动N个线程时, 可以使用java.util.concurrent.CyclicBarrier 类解决。 demo: import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class...
  • 启动一个线程是用run()还是start()

    千次阅读 2017-02-19 12:09:23
    1.start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,这时此线程是处于就绪状态,并没有运行。  ...
  • python3-启动个线程

    千次阅读 2018-10-26 22:45:42
    问题:在for循环里面想同时启动多个线程,但是程序运行过程中产生的是线程一个一个启动,即:启动第一个线程之后主线程等待子线程运行完成之后才启动第二个,代码如下: import threading import time def thread...
  • 有时开启一个线程是为了把耗时的操作转移到线程中执行,主进程中可以执行其它的任务,避免了因为大量的重复性操作导致主进程阻塞。 控制线程暂停的方法: 线程的同步用到了QMutex类,作为一个互斥锁控制进行保护。...
  • Java中main方法启动的是一个线程也是一个进程,一个java程序启动后它就是一个进程,进程相当于一个空盒,它只提供资源装载的空间,具体的调度并不是由进程来完成的,而是由线程来完成的。一个java程序从main开始之后...
  • 1.start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,  这时此线程是处于就绪状态,  并没
  • java同时启动个线程(二)

    千次阅读 2019-03-11 15:13:58
    当我们需要同时启动N个线程时, 可以使用java.util.concurrent.CountDownLatch 类解决。 demo: import java.util.concurrent.CountDownLatch; public class TestCountDownLatch { public static void main...
  • 启动线程肯定要用start()方法。当用start()开始一个线程后,线程就进入就绪状态,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时,才...
  • Java多线程启动个线程,两执行加一,另外两执行减
  • 一个线程也是一个进程,一个java程序启动后它就是一个进程,进程相当于一个空盒,它只提供资源装载的空间,具体的调度并不是由进程来完成的,而是由线程来完成的。一个java程序从main开始之后,进程启动,为整个...
  • java方法中启动一个新的线程

    万次阅读 2017-12-20 10:45:15
    1 要想在java方法中启动一个新的线程。通过new Thread(){public void run(){...}}.start()即可。 如:public static void main(String[] args) { System.out.println("新建议一个线程"); //启动一个新的线程 ...
  • java同时启动个线程

    千次阅读 2016-06-05 12:01:48
     * 启动个线程,这里以100为例  * @author XYQ  *  */ public class TestThread {  public static void main(String[] args){  Thread[] th = new Thread[100];  for(int i=0;i  th[i] = new
  • MFC启动一个线程的三种方法

    千次阅读 2019-03-11 16:40:39
    转载于:... 第一种AfxBeginThread() 用AfxBeginThread()函数来创建一个线程来执行任务,工作者线程的AfxBeginThread的原型如下: CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc, ...
  • java开启新线程的三种方法: 方法1:继承Thread类 ...4):在main方法(线程)中,创建一个线程对象并启动线程。 (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();...
  • 几年前写过一个C++的多线程框架,虽然写完了,但是人一懒做了一次说明以后就没影了,最近把代码整理了一下,准备发到github上,在这里,再把这个框架总结一下吧。 多线程一直是编程中常见的问题,特别是在Linux的...
  • 简单启动一个main程序时,有多少个线程被创建呢? public class OnlyMain { public static void main(String[] args) { //虚拟机线程管理的接口 ThreadMXBean threadMXBean = ManagementFactory....
  • 今天看见一个不错的话题:Java程序启动时至少会启动多少个线程? 刚看到这个话题时,我脑子里首先想到是两个,一个是main线程一个GC回收的线程。我估计大部分人首先想到的也是两个。 其实这么想是没错的,因为它...
  • Linux能同时启动多少个线程

    千次阅读 2013-09-19 10:40:39
    对于 32-bit Linux,一个进程的地址空间是 4G,其中用户态能访问 3G 左右,而一个线程的默认栈 (stack) 大小是 10M,心算可知,一个进程大约最多能同时启动 300 个线程左右 多线程能提高并发度吗? 如果指的是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 932,905
精华内容 373,162
关键字:

如何启动一个线程