精华内容
下载资源
问答
  • Java中实现阻塞有哪些方法 sleep() 方法 释放CPU,不会释放锁 suspend() 和 resume() 方法(在JDK中已经过期) 不推荐使用 suspend() 去挂起线程的原因,是因为 suspend() 在导致线程暂停的同时,并不会

    什么是阻塞?
    没有找到权威定义。
    自己理解:
    通常在Java中,我们说到阻塞,主语是线程。可以理解为线程想要进行下去,但是由于条件没有具备,所以阻塞等待,直到条件具备,该线程知道(被唤醒?),而继续把线程进行下去。

    只要线程暂停-释放cpu使用权就算阻塞吗?

    Java中实现阻塞有哪些方法
    sleep() 方法
    释放CPU,不会释放锁

    suspend() 和 resume() 方法(在JDK中已经过期)
    不推荐使用 suspend() 去挂起线程的原因,是因为 suspend() 在导致线程暂停的同时,并不会去释放任何锁资源。
    其他线程都无法访问被它占用的锁。直到对应的线程执行 resume() 方法后,被挂起的线程才能继续,从而其它被阻塞在这个锁的线程才可以继续执行。

    yield() 方法(算阻塞吗?)
    yield:放弃、停止争论
    会使的线程放弃当前分得的cpu时间片,但此时线程任然处于可执行状态,随时可以再次分得cpu时间片。yield()方法只能使同优先级的线程有执行的机会。调用 yield()的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。(暂停当前正在执行的线程,并执行其他线程,且让出的时间不可知)
    有可能算(释放后,再次争抢CPU没有争抢到),有可能不算?(释放后,又争抢到了CPU)

    wait() 和 notify() 方法
    wait()会释放锁和CPU使用时间。

    join()方法
    也叫线程加入。是当前线程A调用另一个线程B的join()方法,当前线程转A入阻塞状态,直到线程B运行结束,线程A才由阻塞状态转为可执行状态。

    阻塞一定释放CPU和锁吗?

    轮询算阻塞吗?

    展开全文
  • FutureTask类中get方法阻塞的问题: get方法的实现: /** * @throws CancellationException {@inheritDoc} */ public V get() throws InterruptedException, ExecutionException { int s = state;

    FutureTask类中get方法阻塞的问题:

    get方法的实现:

     /**
         * @throws CancellationException {@inheritDoc}
         */
        public V get() throws InterruptedException, ExecutionException {
            int s = state;
            if (s <= COMPLETING)
                s = awaitDone(false, 0L);
            return report(s);
        }

    这里的state是线程完成的标志,线程完成之后该state为2。线程启动之前该值为1。

    COMPLETING的值为1。

    s <= COMPLETING表示当前线程还未执行完。就调用awaitDone方法。

    awaitDone方法中:

    第一个参数:timed true if use timed waits,为false表示不使用timed waits,意思是不设置超时时间,如果线程未完成,会一直阻塞。

    第二个参数:nanos time ,等待的时间。


    awaitDone方法的实现:

    /**
         * Awaits completion or aborts on interrupt or timeout.
         *
         * @param timed true if use timed waits
         * @param nanos time to wait, if timed
         * @return state upon completion
         */
        private int awaitDone(boolean timed, long nanos)
            throws InterruptedException {
            final long deadline = timed ? System.nanoTime() + nanos : 0L;
            WaitNode q = null;
            boolean queued = false;
            for (;;) {
                if (Thread.interrupted()) {
                    removeWaiter(q);
                    throw new InterruptedException();
                }
    
                int s = state;
                if (s > COMPLETING) {
                    if (q != null)
                        q.thread = null;
                    return s;
                }
                else if (s == COMPLETING) // cannot time out yet
                    Thread.yield();
                else if (q == null)
                    q = new WaitNode();
                else if (!queued)
                    queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                         q.next = waiters, q);
                else if (timed) {
                    nanos = deadline - System.nanoTime();
                    if (nanos <= 0L) {
                        removeWaiter(q);
                        return state;
                    }
                    LockSupport.parkNanos(this, nanos);
                }
                else
                    LockSupport.park(this);
            }
        }
    


    展开全文
  • NULL 博文链接:https://superherosk123.iteye.com/blog/611933
  • 因为read()方法阻塞的,如果硬件一直没有数据发过来的话,read()方法会一直阻塞,这个方法我单独放在了一个子线程当中。 但是业务要求在退出时候要释放所有资源,方便第二次启动程序重新连接硬件。但是我在主线程...
  • 1、Future Future模式是多线程设计常用的一种设计模式。Future模式可以理解成:我有一个任务,提交给了Future,Future替我完成这个任务。...向线程池中提交任务的submit方法不是阻塞方法,而Future...

    1、Future

    Future模式是多线程设计常用的一种设计模式。Future模式可以理解成:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。
    Future提供了三种功能:
    判断任务是否完成
    能够中断任务
    能够获取任务执行的结果
    向线程池中提交任务的submit方法不是阻塞方法,而Future.get方法是一个阻塞方法,当submit提交多个任务时,只有所有任务都完成后,才能使用get按照任务的提交顺序得到返回结果,所以一般需要使用future.isDone先判断任务是否全部执行完成,完成后再使用future.get得到结果。(也可以用get (long timeout, TimeUnit unit)方法可以设置超时时间,防止无限时间的等待)
    三段式的编程:1.启动多线程任务2.处理其他事3.收集多线程任务结果,Future虽然可以实现获取异步执行结果的需求,但是它没有提供通知的机制,要么使用阻塞,在future.get()的地方等待future返回的结果,这时又变成同步操作;要么使用isDone()轮询地判断Future是否完成,这样会耗费CPU的资源。
    解决方法:CompletionService和CompletableFuture(按照任务完成的先后顺序获取任务的结果

    2、CompletionService是java1.8之前最好用的方法,

    能够实现按照任务完成的先后顺序获取任务的结果。

    public class TestCompletionService {
    	private static final String commandstr01 = "hahah";
    	private static final String commandstr02 = "hahah";
    	
    	
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		//1、创建一个线程池
    		ExecutorService executorService = Executors.newCachedThreadPool();
    		
    		CompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);
    		
    		completionService.submit(new MyThreadt33(commandstr01));
    		completionService.submit(new MyThreadt44(commandstr01));
    			
    		executorService.shutdown();
    		
    		System.out.println(completionService.take().get());
    		System.out.println(completionService.take().get());
    	}
    }
    
    class MyThreadt33 implements Callable<String>{
    	private String commandstr;          // 要运行的mingling
    	public MyThreadt33(String commandstr) {
    		this.commandstr = commandstr;
    	}
    	@Override
    	public String call() throws Exception {
    		int sum = 0;
    		for (int i = 0; i < 100; i++) {
    			Thread.sleep(200);
    			sum += i;
    			System.out.println("Mythread3: "+i);
    		}
    		return String.valueOf(sum+300000);
    	}
    }
    
    class MyThreadt44 implements Callable<String>{
    	private String commandstr;          // 要运行的mingling
    	public MyThreadt44(String commandstr) {
    		this.commandstr = commandstr;
    	}
    	@Override
    	public String call() throws Exception {
    		int sum = 0;
    		for (int i = 0; i < 50; i++) {
    			Thread.sleep(200);
    			sum += i;
    			System.out.println("Mythread4: "+i);
    		}
    		return String.valueOf(sum+400000);
    	}
    }

    CompletionService方法可以通过completionService.take().get()方法获取最快完成的线程的返回结果(若当前没有线程执行完成则阻塞直到最快的线程执行结束),第二次调用则返回第二快完成的线程的返回结果。

    3、CompletableFuture接口

    所谓异步调用其实就是实现一个可无需等待被调函数的返回值而让操作继续运行的方法。简单的讲就是另启一个线程来完成调用中的部分计算,使调用继续运行或返回,而不需要等待计算结果。但调用者仍需要取线程的计算结果。

    JDK1.5新增了Future接口,用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力,但是对于结果的获取却是很不方便,只能通过阻塞或者轮询的方式得到任务的结果。

    JDK1.8后提出了CompletableFuture接口实现了Future和CompletionStage两个接口,CompletionStage可以看做是一个异步任务执行过程的抽象(CompletionStage代表异步计算过程中的某一个阶段,一个阶段完成以后可能会触发另外一个阶段,一个阶段的计算执行可以是一个Function,Consumer或者Runnable。比如:

    stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println()))

    我们可以基于CompletableFuture创建任务和链式处理多个任务,并实现按照任务完成的先后顺序获取任务的结果。

    (1)创建任务

    ##使用runAsync方法新建一个线程来运行Runnable对象(无返回值)

    ##使用supplyAysnc方法新建线程来运行Supplier<T>对象(有返回值)

    ##基于线程池创建

    (2)任务的异步处理

    不论Future.get()方法还是CompletableFuture.get()方法都是阻塞的,为了获取任务的结果同时不阻塞当前线程的执行,我们可以使用CompletionStage提供的方法结合callback来实现任务的异步处理。

    ##whenComplete:是执行当前任务的线程执行继续执行 whenComplete 的任务。
    ##whenCompleteAsync:把 whenCompleteAsync 这个任务继续提交给线程池来进行执行,也就是并行执行。

    ##thenApply:当一个线程依赖另一个线程时,可以使用 thenApply 方法来把这两个线程串行化

    ##thenAcceptthenAccept接收上一阶段的输出作为本阶段的输入,并消费处理,无返回结果。 

    ##thenRun:不关心前一阶段的计算结果,因为它不需要输入参数,进行消费处理,无返回结果。

    ## thenCombine:会把两个 CompletionStage 的任务都执行完成后,把两个任务的结果一块交给 thenCombine 来处理。

    ## applyToEither :两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的转化操作。

    ##acceptEither 方法:两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的消耗操作

    public class TestCompletableFuture {
    	private static final String commandstr01 = "hahah";
    	private static final String commandstr02 = "hahah";
    	private static final String commandstr03 = "hahah";
    	private static final String commandstr04 = "hahah";
    
    	    public static void main(String[] args) throws InterruptedException, ExecutionException{
    	        
    	    	ExecutorService executorService = Executors.newCachedThreadPool();
    	    	
    	        CompletableFuture.supplyAsync(new MyThreadt444(commandstr02),executorService).whenComplete((result, e) -> {
    	        	//执行线程执行完以后的操作。
    	            System.out.println(result + " " + e);
    	        }).exceptionally((e) -> {
    	            //抛出异常
    	        	System.out.println("exception " + e);
    	            return "exception";
    	        });
    	        
    	         CompletableFuture.supplyAsync(new MyThreadt333(commandstr02),executorService).whenComplete((result, e) -> {
    	        	//执行线程执行完以后的操作。
    	        	System.out.println(result + " " + e);
    	        }).exceptionally((e) -> {
    	            System.out.println("exception " + e);
    	            return "exception";
    	        });
    	    }
    }
    
    
    
    class MyThreadt333 implements Supplier<String>{
    
    	private String commandstr;          // 要运行的mingling
    	public MyThreadt333(String commandstr) {
    		this.commandstr = commandstr;
    	}
    	@Override
    	public String get() {
    		int sum = 0;
    		for (int i = 0; i < 30; i++) {
    			try {
    				Thread.sleep(200);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			sum += i;
    			System.out.println("Mythread333: "+i);
    		}
    		return String.valueOf(sum+300000);
    	}
    }
    
    class MyThreadt444 implements Supplier<String>{
    
    	private String commandstr;          // 要运行的mingling
    	public MyThreadt444(String commandstr) {
    		this.commandstr = commandstr;
    	}
    	@Override
    	public String get() {
    		int sum = 0;
    		for (int i = 0; i < 40; i++) {
    			try {
    				Thread.sleep(200);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			sum += i;
    			System.out.println("Mythread444: "+i);
    		}
    		return String.valueOf(sum+400000);
    	}
    }

    在CompletableFuture接口中除了使用whenComplete还可以使用handle等方法能实现按照任务完成的先后顺序获取任务的结果。

    4、几种多线程并发取结果方式的总结

    下图参考自:https://blog.csdn.net/u011726984/article/details/79320004

    展开全文
  • 目前在做一个串口通信的app,过程中pc模拟单片机给开发板串口发送命令时候出现了问题,inputStream.read方法一直阻塞,完全无法读取到数据,用了网上一个方法,while判断size=-1时候跳出循环,实际上,根本不会跳...

    目前在做一个串口通信的app,过程中pc模拟单片机给开发板串口发送命令时候出现了问题,inputStream.read方法一直阻塞,完全无法读取到数据,用了网上一个方法,while判断size=-1时候跳出循环,实际上,根本不会跳出去。

    read方法是这样的:

    *Reads some number of bytes from the input stream and stores them into
    * the buffer array <code>b</code>. The number of bytes actually read is
    * returned as an integer.  This method blocks until input data is
    * available, end of file is detected, or an exception is thrown.
    *
    * <p> If the length of <code>b</code> is zero, then no bytes are read and
    * <code>0</code> is returned; otherwise, there is an attempt to read at
    * least one byte. If no byte is available because the stream is at the
    * end of the file, the value <code>-1</code> is returned; otherwise, at
    * least one byte is read and stored into <code>b</code>.
    *
    * <p> The first byte read is stored into element <code>b[0]</code>, the
    * next one into <code>b[1]</code>, and so on. The number of bytes read is,
    * at most, equal to the length of <code>b</code>. Let <i>k</i> be the
    * number of bytes actually read; these bytes will be stored in elements
    * <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
    * leaving elements <code>b[</code><i>k</i><code>]</code> through
    * <code>b[b.length-1]</code> unaffected.
    *
    * <p> The <code>read(b)</code> method for class <code>InputStream</code>
    * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>

    简答翻译一下就是:

    从输入流中读取一些字节数并将它们存储到缓冲区数组b 中。实际读取的字节数以整数形式返回。此方法将阻塞,直到输入数据可用,检测到文件结尾或引发异常。

    如果b 的长度为零,则不读取任何字节,并返回 0 ;否则,尝试读取至少一个字节。如果没有字节可用,因为流位于文件的末尾,则返回值-1 ;否则,至少读取一个字节并将其存储到 b 中。 读取的第一个字节存储在元素 b [0] 中, next存入 b [1] ,依此类推。读取的字节数最多等于b 的长度。设 k为实际读取的字节数;这些字节将存储在元素b [0] 到 b [ k -1] ,离开元素b [ k ] 到 b [b.length-1] 不受影响。 类 InputStream 的read(b)方法具有与以下相同的效果:read(b,0,b.length)

     

    这个方法能够正常读取文件流,因为文件总是有大小的,所以总能读到末尾返回-1,但是串口(貌似网络)流也是这样,完全无法判断在哪结束,也无法抛出异常,所以,并不会返回任何数值。

     

    我之前还出现过一个问题,我以为是串口app每次读取四个字节,实际上后来发现是我pc串口助手所用的发送的数据格式,数据位就是8。

     

    所以最后,决定只能设置超时时间

     

    展开全文
  • socket read方法阻塞解决方法

    千次阅读 2019-06-29 09:44:04
    def readRequestContent(in:InputStream):String = { //这里为防止一次读取不完 var sb = new StringBuilder for(i <- 0 to 5) { var len = in.available() //这里为了防止read方法一直阻塞 while (le...
  • 阻塞方法

    2020-12-13 15:00:04
    阻塞方法 线程阻塞阻塞方法阻塞的线程往往需要等待一个不受它控制的事件发生后才能继续执行,如等待I/O操作完成,等待某个锁可用或等待一个外部计算结束。而可以导致线程阻塞方法,我们称为 阻塞方法。 在 ...
  • String[] cmd = { exe的路径, 参数 ... 为了实现确保调用的exe程序执行完毕再执行其他函数,使用java progress的.waitfor()方法,但特别容易出现堵塞,上网查了下通过上述方法可以完美解决,算得上是一个小小的收获吧。
  • Socket编程---read方法阻塞问题

    千次阅读 2018-12-25 21:32:23
    那么,回到我们的聊天室来,我一个服务器要处理这么多个客户端,如果一个客户端的read方法阻塞了,那别的客户端不都得等着它吗?显然,这是不可能的。那,一个客户端给一个线程吧,让它们自己阻塞自己的。 对于...
  • java方法声明为synchronized会导致c通过jni调用java方法阻塞,why?
  • HttpURLConnection getResponseCode()方法阻塞

    万次阅读 2016-06-04 18:07:43
    近期Quartz抓取程序是不是会阻塞,一直以为是Quartz版本太低存在bug。今天又阻塞了,无法容忍了,开始找原因: 1、先从日志中找到了执行job的线程 ...可见,问题出在HttpURLConnection的getResponseCode()方法上,
  • Go 永久阻塞方法

    2021-01-24 07:23:47
    下面我总结了几种可以实现永久阻塞方法,其中大部分实例代码无法直接运行,因为 Go runtime 会检查所有 goroutine 并提示所有的 goroutine 都处于 deadlock,在实际使用中,我们添加具体的业务 goroutien 就可以...
  • 实现Java阻塞有哪些方法

    千次阅读 2019-01-22 16:47:25
    如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触...
  • 刚刚看关于文件上传的课程,记录自己对于read方法阻塞的理解。如有问题,希望大家指正。 read方法调用后,会阻塞(程序暂停在read方法使用处)。 阻塞后,read方法有多种情况会解除阻塞: 1.检测到有输入数据可用。...
  • 堆是由所有的线程共享的,但是在线程执行这个对象某个方法时,是在自己的栈中,又因为线程间的栈(虚拟机栈,不是本地方法栈)是互相独立的,所以只要不加锁是不会引起阻塞。 而且sleep期间是会释放cpu的。 不知道我...
  • 解决程序堵塞的优化方法(一)

    千次阅读 2020-02-22 23:46:02
    刚开始学习写嵌入式的代码,例如在...但是我们需要了解,当程序使用大量类似delay形式的函数对程序造成严重阻塞。 以delay延时函数为例:一般程序写都是通过while()或者for()条件判进行断循环累加,如果延时函数...
  • 主要介绍了处理java异步事件的阻塞和非阻塞方法分析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,阻塞与非阻塞关注的是交互双方是否可以弹性工作。,需要的朋友可以参考下
  • 针对当前集中交易为主同时存在大用户直供试点的市场模式,提出了一种点对点阻塞电价计算方法。给出了该算法的基本思想及详细描述,根据集中交易中无约束经济调度和考虑单个阻塞线路传输容量经济调度购电成本的差值计算...
  • BufferedReader的readLine方法阻塞的处理

    万次阅读 热门讨论 2016-06-15 10:46:23
    BufferReader的read方法和readLine方法在任何情况下都是阻塞的。readLine方法每次读一行,相对于一个字符/字节地读取、转换、返回来说,它有一个缓冲区,读满缓冲区才返回;一般情况下,都建议使用它们把其它Reader/...
  • Thread.join方法阻塞当前线程

    千次阅读 2012-02-20 22:16:41
    * 运行机制:调用join方法的线程对象先执行完成,调用该方法时所在线程将会被阻塞,直到 * 调用join方法的线程执行完成 * @author zhouli * */ public class TestJoin { private static M...
  • Python中Queue.get()方法阻塞

    千次阅读 2019-07-23 19:04:52
    原文: https://blog.csdn.net/quantum7/article/details/88556238 嗯,吾亦木有想到.加参数False即可: ... 可以指定阻塞时间,这个就没必要了.  当然,也可以直接调用get_nowait()  
  • 使用CompletionService解决Future的get方法阻塞问题 解决方法: CompletionService 的take()方法获取最先执行完的线程的Future对象。 详情:http://www.ya​yihouse.com/yayishuwu/chapter/1546...
  • ps -no pid -I THREAD,tid,time printf “%x\n” 线程pid (转换成16进制) jstack pid|grep b32 -A 30 (pid为进程号,b32为线程转换后16进制字符)
  • LinkedBlockingDeque自动...add方法无返回值,满了报异常,offer方法满了return false,put方法满了await自动阻塞。 以putFirst(E e)为例: final ReentrantLock lock = new ReentrantLock(); private final Condit...
  • Socket中的read方法阻塞问题

    千次阅读 2017-11-22 12:22:33
    这个方法的意思是返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。即需要读取的字节数 那为什么不直接 len = in.available(); 一次而不用循环呢 可是在进行网络操作时往往...
  • jedisPool.getResource()方法长时间无响应并且不报错,方法阻塞   这个锅真的是蓝瘦,,,表现是项目重启后一开始可以,过段时间,哎,不行了,,,,查了一半天发现,原因在于jedis连接用完了,然后默认给阻塞了...
  • 前言: 由于要从硬件传感器端接收已经规定好的字符串数据,硬件方采用4G将数据发送,用socket编程将数据判别...问题出现在硬件方在发送完数据后不能自行关闭socket,而readline()方法 在客户端socket未主动关闭 或者...
  • Selector select方法阻塞register的解决方法
  • 本文实例讲述了PHP实现非阻塞模式的方法。分享给大家供大家参考,具体如下: 程序非阻塞模式,这里也可以理解成并发。而并发又暂且可以分为网络请求并发 和本地并发 。 先说一下网络请求并发 理论描述 假设有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 685,358
精华内容 274,143
关键字:

方法的阻塞