精华内容
下载资源
问答
  • 线程运行一次后,它的run方法执行完了就无法重新用start启动了。 如果想再执行一遍run方法,只能重新new 一个线程实例再start?
  • 【多线程】获取多线程执行结果

    千次阅读 2020-04-02 12:52:12
    1. 观察者模式结合多线程实现获取线程执行结果 在多线程开发中,我们没办法获取线程执行完成后的结果,但是当我们利用观察者模式的时候我们就可以获取到多线程的执行结果 2.具体实现 假设目前有一批id需要查询并...

    1. 观察者模式结合多线程实现获取线程执行结果

    在多线程开发中,我们没办法获取线程执行完成后的结果,但是当我们利用观察者模式的时候我们就可以获取到多线程的执行结果

    2.具体实现

    假设目前有一批id需要查询并需要获得查询结果, 利用多线程结合设计模式实现

    2.1 LifeCycleListener

    public interface LifeCycleListener {
        void onEvent(ObserverableRunnable.RunnableEvent event);
    }
    

    2.2 ObserverableRunnable

    
    public abstract class ObserverableRunnable implements Runnable{
    
        /**
         * 监听这
         */
        final protected LifeCycleListener listener;
    
        public ObserverableRunnable(LifeCycleListener listener) {
            this.listener = listener;
        }
    
    
        public void notifyChange(final RunnableEvent event) {
            listener.onEvent(event);
        }
    
        public enum RunnableState {
            RUNNING, ERROR, DONE;
        }
    
        /**
         * 内部类尽量都是静态的,不然作为成员对象每次创建对象都会复制
         */
        public static class RunnableEvent {
    
            private final RunnableState state;
            private final Thread thread;
            private final Throwable cause;
    
    
            public RunnableEvent(RunnableState state, Thread thread, Throwable cause) {
                this.state = state;
                this.thread = thread;
                this.cause = cause;
            }
    
            public RunnableState getState() {
                return state;
            }
    
            public Thread getThread() {
                return thread;
            }
    
            public Throwable getCause() {
                return cause;
            }
        }
    }
    
    

    2.3 ThreadLifeCycleObserver

    package com.gy.observer;
    
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.IntStream;
    
    /**
     * 模拟当前类使用多线程需要去处理一批id,并拿到结果
     * 1. 创建处理方法并通过ObserverableRunnable去执行任务
     * 2. 当ObserverableRunnable吧任务执行完成后提醒当前类做完了
     * 3. 拿到返回值处理
     */
    public class ThreadLifeCycleObserver implements LifeCycleListener {
    
    
        private Object LOCK = new Object();
    
        private void concurrentQuery(List<Integer> ids) {
            if (ids.size() == 0 && ids.isEmpty())
                return;
    
            ids.stream().forEach((id)->{
                new Thread(new ObserverableRunnable(this) {
                    @Override
                    public void run() {
                        try {
                            notifyChange(new RunnableEvent(RunnableState.RUNNING,  Thread.currentThread(), null));
                            System.out.printf("query for id = %s\n", id);
                            Thread.sleep(1000);
                            notifyChange(new RunnableEvent(RunnableState.DONE,  Thread.currentThread(), null));
                        } catch (InterruptedException e) {
                            notifyChange(new RunnableEvent(RunnableState.ERROR,  Thread.currentThread(), e));
                        }
                    }
                }).start();
            });
        }
    
    
    
        /**
         * 这个方法可能是多个线程在回调所以需要使用同步锁
         * @param event
         */
        @Override
        public void onEvent(ObserverableRunnable.RunnableEvent event) {
            synchronized (LOCK) {
                System.out.println(event.getThread().getName() + " == " + event.getState());
            }
        }
    
    
        public static void main(String[] args) {
            ThreadLifeCycleObserver threadLifeCycleObserver = new ThreadLifeCycleObserver();
            threadLifeCycleObserver.concurrentQuery(Arrays.asList(1, 2, 3));
        }
    }
    
    
    展开全文
  • Thread tr = null; delegate void Methinvoker(); private void btSeInfo_Click(object sender, EventArgs e) { tr = new Thread(new ThreadStart(SeleInfo)); tr

     
            Thread tr = null;
            delegate void Methinvoker();
            private void btSeInfo_Click(object sender, EventArgs e)
            {
    
                tr = new Thread(new ThreadStart(SeleInfo));
                tr.IsBackground = true;
                //  tr.SetApartmentState(ApartmentState.STA);
                tr.Start();
    
    
                Thread tr1 = new Thread(new ThreadStart(StartThreadCaiji));
                tr1.Start();
            }
            private void StartThreadCaiji()
            {
                tr.Join();
                Methinvoker meth = new Methinvoker(MessSeInfo);
                this.BeginInvoke(meth);
            }
            private void MessSeInfo()
            {
    
                //Monitor.Enter(obj);
                // Monitor.Wait(obj);
                MessageBox.Show("数据采集完成,成功采集记录总数:【" + caiji.ToString() + "】条\n 其中红色讯号灯表示通讯错误,绿色表示提取成功!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                pbLoad.Value = 0;
                tbpg.Text = "";
                caiji = 0;
                btStopSelect.Enabled = false;
                //   Monitor.Exit(obj);
            }


    当然还可以用Monitor来锁 这就不解释了
    展开全文
  • 控制多线程执行顺序

    千次阅读 2018-11-01 14:30:58
    控制多线程执行顺序 示例代码的码云地址:https://gitee.com/suwenguang/test/blob/master/fuxi/src/main/java/多线程/控制多线程的顺序执行/App.java 多线程是为了同步完成多项任务,不是为了提高运行效率,而是...

    个人博客:https://suveng.github.io/blog/​​​​​​​

    控制多线程的执行顺序

    示例代码的码云地址:https://gitee.com/suwenguang/test/blob/master/fuxi/src/main/java/多线程/控制多线程的顺序执行/App.java

    多线程是为了同步完成多项任务,不是为了提高运行效率,而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。

    我们在运行多线程的程序时,假设线程逐一启动的,但是发现线程的执行并不是逐一执行的。这是因为CPU随机调度的问题,谁分配到CPU谁就执行,如果好奇进程调度算法可以自行Google。

    大概的思路可以这样子理一下:

    程序启动->CPU分配内存给Java进程->Java进程的程序建立线程->进程分配线程空间->线程随机获取CPU执行->线程结束->主线程结束,进程销毁

    这里关键是线程是随机获取CPU执行的

    想要控制线程的执行顺序应该怎么做?

    1. 使用join()方法
    2. 使用SingleThreadExecutor线程池

    使用join()方法

    public void joinTest() throws InterruptedException {
    //        通过join() 方法保证线程的顺序,但是这样子就和单线程没什么区别了。
    //        join()是让主线程等待子线程结束后 继续运行
            thread1.start();
            thread1.join();
    
            thread2.start();
            thread2.join();
    
            thread3.start();
            thread3.join();
        }
    

    join()是让主线程等待子线程结束后,继续运行。

    使用SingleThreadExecutor线程池

    /**
     * 通过singleThreadPool来控制线程顺序,singleThreadPool是FIFO先进先出的一个线程池
     */
    @Test
    public void executorTest(){
        executorService.submit(thread1);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("i am second");
            }
        });
        executorService.submit(() -> System.out.println("i am third"));
        executorService.submit(thread2);
        executorService.submit(thread3);
    }
    

    其作用类似于线程队列,提交任务到队列,线程池负责调度,并根据先进先出的规则执行,这样就可以保证线程的顺序执行了。

    展开全文
  • Thread thread = new Thread(SendOtherData); thread.Start();
  • 在方法的外部申请一个这样的变量 CountdownEvent latch = ...比如现在执行的是方法a public void a() { int si=0,ei=0; Thread thread = new Thread(() =&gt; refreshData(si, ei)); thread .start();...

    在方法的外部申请一个这样的变量
    CountdownEvent latch = new CountdownEvent(3);
    比如现在执行的是方法a
    public void a()
    {
    int si=0,ei=0;
    Thread thread = new Thread(() => refreshData(si, ei));
    thread .start();
    thread = new Thread(() => refreshData(si, ei));
    thread .start();
    thread = new Thread(() => refreshData(si, ei));
    thread .start();
    latch.Wait();
    MessageBox.Show(start.ToString() + “,,,” + end.ToString());
    }
    private void refreshData(int start, int end)
    {
    latch.Signal();
    }
    这样会等到三个线程全部执行完后才会出现 messagebox提示框,

    展开全文
  • 在多线程环境下,我们可能会需要等待开辟的线程执行完后,再去执行某个方法,例如输出并行计算结果等。 但是在多线程下,线程的执行是不阻塞主线程的,这点其实也是多线程的优势,提高代码执行效率,不必相互等待...
  • 如何控制线程执行的顺序?

    万次阅读 2018-01-11 22:56:43
    如何控制线程执行的顺序? 要解决如上的题目,得理解题意的重心在哪。关键词:线程与顺序。 先来一段多线程执行的代码。 public class Test { public static void main(String[] args) { Thread t1 = new ...
  • 如何获取多线程执行结果-java

    千次阅读 2021-08-12 16:08:05
    在日常的项目开发中,我们会经常遇到通过多线程执行程序并需要返回执行结果的场景,下面我们就对获取多线程返回结果的几种方式进行一下归纳,并进行简要的分析与总结。 一、Thread.join 在一些简单的应用场景中...
  • 线程控制线程执行顺序

    千次阅读 2018-04-19 00:19:20
    如何控制线程执行的顺序?要解决如上的题目,得理解题意的重心在哪。关键词:线程与顺序。先来一段多线程执行的代码。public class Test { public static void main(String[] args) { Thread t1 = new Thread(new ...
  • public class Test04 implements Runnable { private static int count=0; @Override ...// System.out.print("线程1:"); tt.start(); tt2.start(); tt3.start(); tt4.start(); } }
  • java让2个线程交替执行,每个线程执行1秒: package tf56.SpringBoot.Annotation; /** * Created by Administrator on 2017/10/17. */ public class Test2 { private static int state = 1; public static ...
  • Java利用多线程执行SQL减少执行时间提高效率 首先这是个人在实际的项目中使用的代码,部分敏感代码没有上,不过不影响对代码的理解: 1.实现自己的线程 /** * * @author * @date */ package ...
  • 这里记录一下下面这种情况:主线程需要等待多个子线程执行完后再执行。 1.使用CountDownLatch 示例如下,我们初始化一个CountDownLatch,值为10(子线程个数),然后每次一个子线程执行完后执行一下countDown()...
  • java指定线程执行顺序

    千次阅读 2018-12-06 11:43:11
    如果我们需要将线程执行顺序调整为 t3 -> t2 -> t1。那么在t3的线程中加入t2.join,t2的线程中加入t1.join方式即可解决。 第二种方式我们可以用线程池解决。 public class ThreadYield extends Thread { ....
  • Java中停止线程执行的方法

    万次阅读 2015-06-27 15:51:29
    Java中停止线程执行的方法作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、暂停或停止线程的理论在Java编程中,要暂停或停止当前正在运行的线程,有几种方法。对于把线程转入睡眠Sleep状态,使用...
  • 一个线程执行多个任务,要按照顺序执行import java.util.concurrent.ArrayBlockingQueue;/** * 一个线程执行多个任务,要按照顺序执行,怎么去实现? * 分析: * 多个人任务-->线程 * 要按照顺序执行--》就需要...
  • C#开启新线程执行方法

    千次阅读 2018-01-31 12:56:00
    1.创建新的线程并传入指定的参数 Thread thread = new Thread(new ParameterizedThreadStart(RunRefreshProjectMoneyAndOtherMoney)); object[] paramObj = { Token, source.KeyID };...2.执行方法接收线程参数 v
  • 线程执行设置超时时间

    万次阅读 2019-03-18 17:39:57
    import java.util.concurrent.*;... * 线程执行设置超时时间 */ public class Main2 { // 定义线程池,推荐手动创建线程池: https://blog.csdn.net/LLLLLiSHI/article/details/88057655 private static Exec...
  • Java中等待线程执行完毕

    千次阅读 2017-07-18 23:10:27
    前言:前一段时间在做项目的时候,某段代码中用到了多线程,该处代码需要开启多个线程,待这几个线程执行完毕后再接着执行后续的流程。现将可采用的方法记录如下。 要达到上述的描述的情形,可以使用Thread的join()...
  • public static void main(String[] args) throws ExecutionException, InterruptedException ...ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque&...
  • final Lock lc = new ReentrantLock(); .. run() { lc.lock();...改用join() 可以实现(BC与A以单线程模式执行),代码如下: package com.w.thread; import java.util.concurrent.locks.Lock; import ...
  • 如何控制线程执行的先后顺序

    千次阅读 2016-05-01 15:10:52
    答案是:使用线程的join方法,该方法的作用是“等待线程执行结束”,即join()方法后面的代码块都要等待现场执行结束后才能执行。事例代码如下: Java代码 package com.liuan.job;   public class ...
  • 线程执行框架Executor详解

    千次阅读 2014-12-13 14:49:29
    为了能够更好的进行多线程编程,JDK提供了一套Executor执行框架,简化开发人员的对多线程的编程工作。 其框架结构图如下: 框架图比较庞大,但我们只需要关注如下几个实现: Executor接口:只有一个 execute ...
  • java中线程执行顺序控制

    千次阅读 2016-08-19 19:50:53
    thread.Join把指定的线程加入到当前线程,可以将两个交替执行线程合并为顺序执行线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。 public class JoinTest2 { ...
  • Android主线程等待子线程执行结果

    万次阅读 2018-01-16 15:45:08
    在主线程复杂逻辑中,有时候想获取网络数据或者其他一些必须放在子线程中操作的业务时,一般都要新开线程,等待线程执行完成之后使用Handler发送到主线程,然后主线程再往下执行,这样的多次切换会造成逻辑复杂难懂....
  • new MyThread(1).start(); new MyThread(2).start(); new MyThread(3).start(); new MyThread(4).start(); new MyThread(5).start(); new MyThread(6).start(); new MyThread(7).start(); } } ...
  • QT 启动新线程执行QTimer

    千次阅读 2017-05-11 13:56:01
    编写QT程序时,时常会需要使用定时器QTimer来执行一些定时任务,但当定时任务执行的时间过长,则会影响整个界面的响应,因此会想到使用另一个工作线程执行定时器,一般情况下可以选择从QThread派生一个线程类,...
  • 线程从启动到执行完毕,一般会有一些耗时操作,并不能像一般的程序语句,就能立马结束。如下代码: package com.xxx.async; public class WaitThreadDone { public static void main(String[] args) { Thread ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 910,387
精华内容 364,154
关键字:

new线程执行