精华内容
下载资源
问答
  • 编码(encode())和解码(decode()) 使用事例: #编码可以查到下一句的那个码 print("我爱你".encode('utf-8')) #这个就是解码,可以到编译器运行一下哈哈,给你一种向不解风情的程序员委婉地表白的方式...
    • 个人笔记和刚好七夕看到这个,皮一下

    • 这几个是常用的编码表,有时候编译器会发出错误,也是因为编码表不同的问题。下图是各个编码标的适用性范围

    在这里插入图片描述

    • 编码(encode())和解码(decode())

      • 使用事例:
    #编码,这个就会输出下一句的那一串
    print("我爱你".encode('utf-8'))
    #解码,可以到编译器运行一下哈哈,给你一种向不解风情的程序员委婉地表白的方式,
    #没错,这个会输出我爱你。
    print(b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'.decode('utf-8'))
    
    #其中这两个的类型也不一样,第一个是<class 'str'>,第二个是<class 'bytes'>。
    #所以开头的b就是表示这个是bytes类型
    print(type('我爱你'))
    print(type(b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0')
    
    展开全文
  • wait()也是一种使线程暂停执行的方法,例如,当线程交互时,如果线程对一个同步对象x发出一个wait()调用请求,那么该线程会暂停执行,被调对象进入等待状态,直到被唤醒或等待时间超时。 二者的区别主要为以下...

    sleep()方法与wait()方法的区别

    sleep()是使线程暂停执行一段时间的方法。wait()也是一种使线程暂停执行的方法,例如,当线程交互时,如果线程对一个同步对象x发出一个wait()调用请求,那么该线程会暂停执行,被调对象进入等待状态,直到被唤醒或等待时间超时。
    二者的区别主要为以下几点:
    (1)原理不同。
    sleep()方法是Thread类的静态方法,是线程用来控制自身流程的,会使此线程暂停执行一段时间,把执行机会让给其他线程,等时间一到此线程会自动“苏醒”。
    wait()方法是Object()类的方法,用于线程间的通信,这个方法会使当前拥有该对象锁的进程等待,直到其他线程调用notify()方法(或notifyAll()方法)才“苏醒”。
    (2)对锁的处理机制不同
    sleep()方法的主要作用是让线程暂停执行一段时间,时间一到自动恢复,不涉及线程间的通信,因此调用sleep()方法并不会释放锁。
    调用wait()方法后,线程会释放掉它所占用的锁,从而使线程所在对象中的其他synchronized数据可被别的线程使用。
    (3)使用区域不同
    sleep()方法可以放在任何地方使用。
    wait()方法必须放在同步控制方法或同步语句块中使用。
    (4)异常捕获
    sleep方法必须捕获异常,在sleep过程中,有可能被其他对象调用它的interrupt()产生InterruptException异常。
    wait()、notify()、notifyAll()不需要捕获异常

    由于sleep不会释放“锁标志”,容易导致死锁。因此一般推荐使用wait()方法

    sleep()方法与yield()方法的区别

    (1)优先级
    sleep()方法运行时不考虑线程优先级,因此会给低优先级的线程运行的机会;
    yield()方法只会给相同优先级或更高优先级的线程以运行的机会
    (2)状态
    线程运行sleep()方法后会转入阻塞状态,所以执行sleep()方法的线程在指定的时间内不会被执行。
    yield()方法使当前线程重回到可执行状态,所以执行yield()方法的线程有可能在进图到可执行状态后又马上被执行。
    (3)异常
    sleep()方法生命抛出InterruptException,而yield()方法没有声明任何异常
    (4)可操作性
    sleep()方法比yield()方法(跟操作系统相关)具有更好的移植性。

    展开全文
  • 将可观察对象发出的项转换为其他可观察对象是RX编程的重要部分。有几种种常见的转换操作符可以...//变换操作符flatMap() switchMap() concatMap() concatMapEager()的区别以及开发中使用的注意点 //首先我们创建四...

    将可观察对象发出的项转换为其他可观察对象是RX编程的重要部分。有几种种常见的转换操作符可以做到这一点,每种操作符都有不同的优点。在下面这个例子中,我将试图解释微妙的差异,并指出这些操作符的最佳用法。

    直接上代码:

    //变换操作符flatMap() switchMap() concatMap()  concatMapEager()的区别以及开发中使用的注意点
    
           //首先我们创建四个用于测试的调度器
            final TestScheduler testScheduler1 = new TestScheduler();
            final TestScheduler testScheduler2 = new TestScheduler();
            final TestScheduler testScheduler3 = new TestScheduler();
            final TestScheduler testScheduler4 = new TestScheduler();
            String[] strArr = {"a","b","c","d"};
            final int delay = 5000;
    
            Observable.fromArray(strArr)
                    .flatMap(new Function<String, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(@NonNull String s) throws Exception {
    
                            return Observable.just(s+"---rxjava").delay(delay,TimeUnit.MILLISECONDS,testScheduler1).doOnNext(new Consumer<String>() {
                                @Override
                                public void accept(@NonNull String s) throws Exception {
                                    Log.d(TAG, "timeflatMap1 :" + testScheduler1.now(TimeUnit.MILLISECONDS));
                                }
                            });
                        }
                    }).doOnNext(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.d(TAG, "accept: timeflatMap2 " + testScheduler1.now(TimeUnit.MILLISECONDS));
                }
            })
                    .subscribe(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.d(TAG, "accept: flatMap : " + s + " timeflatMap3 : " + testScheduler1.now(TimeUnit.MILLISECONDS));
                }
            });
            
            //将调度程序的时钟按指定的时间向前移动10分钟看打印出来的数据
            testScheduler1.advanceTimeBy(10,TimeUnit.MINUTES);
    
            Observable.fromArray(strArr)
                    .concatMap(new Function<String, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(@NonNull String s) throws Exception {
    
                            return Observable.just(s+"---rxjava").delay(delay,TimeUnit.MILLISECONDS,testScheduler2).doOnNext(new Consumer<String>() {
                                @Override
                                public void accept(@NonNull String s) throws Exception {
                                    Log.d(TAG, "timeconcatMap1 :" + testScheduler2.now(TimeUnit.MILLISECONDS));
                                }
                            });
                        }
                    }).doOnNext(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.d(TAG, "accept: timeconcatMap2 " + testScheduler2.now(TimeUnit.MILLISECONDS));
                }
            })
                    .subscribe(new Consumer<String>() {
                        @Override
                        public void accept(@NonNull String s) throws Exception {
                            Log.d(TAG, "accept: concatMap : " + s + " timeconcatMap3 : " + testScheduler2.now(TimeUnit.MILLISECONDS));
                        }
                    });
            
            //将调度程序的时钟按指定的时间再向前累加移动10分钟看打印出来的数据
            testScheduler2.advanceTimeBy(10,TimeUnit.MINUTES);
    
            Observable.fromArray(strArr)
                    .concatMapEager(new Function<String, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(@NonNull String s) throws Exception {
    
                            return Observable.just(s+"---rxjava").delay(delay,TimeUnit.MILLISECONDS,testScheduler3).doOnNext(new Consumer<String>() {
                                @Override
                                public void accept(@NonNull String s) throws Exception {
                                    Log.d(TAG, "timeconcatMapEager1 :" + testScheduler3.now(TimeUnit.MILLISECONDS));
                                }
                            });
                        }
                    }).doOnNext(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.d(TAG, "accept: timeconcatMapEager2 " + testScheduler3.now(TimeUnit.MILLISECONDS));
                }
            })
                    .subscribe(new Consumer<String>() {
                        @Override
                        public void accept(@NonNull String s) throws Exception {
                            Log.d(TAG, "accept: concatMapEager : " + s + " timeconcatMapEager3 : " + testScheduler3.now(TimeUnit.MILLISECONDS));
                        }
                    });
            testScheduler3.advanceTimeBy(10,TimeUnit.MINUTES);
    
            Observable.fromArray(strArr)
                    .switchMap(new Function<String, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(@NonNull String s) throws Exception {
    
                            return Observable.just(s+"---rxjava").delay(delay,TimeUnit.MILLISECONDS,testScheduler4).doOnNext(new Consumer<String>() {
                                @Override
                                public void accept(@NonNull String s) throws Exception {
                                    Log.d(TAG, "timeswitchMap1 :" + testScheduler4.now(TimeUnit.MILLISECONDS));
                                }
                            });
                        }
                    }).doOnNext(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.d(TAG, "accept: timeswitchMap2 " + testScheduler4.now(TimeUnit.MILLISECONDS));
                }
            })
                    .subscribe(new Consumer<String>() {
                        @Override
                        public void accept(@NonNull String s) throws Exception {
                            Log.d(TAG, "accept: switchMap : " + s + " timeswitchMap3 : " + testScheduler4.now(TimeUnit.MILLISECONDS));
                        }
                    });
    
            testScheduler4.advanceTimeBy(10,TimeUnit.MINUTES);

    打印结果:

                    

    通过以上结果我们可以得出:

       flatMap():返回的item是无序的哪个item任务先完成就返回哪个item让下游进行处理 可以同时并行处理多个item的转换

       concatMap():返回的item是有序的,其内部是严格按照上游Observable发射的数据item的顺序一个一个任务执行并返回

                          同时让下游进行响应处理的

       switchMap():当上游Observable有新的数据item发射出来的时候会取消订阅之前的Observable通知订阅和监视最新的

                         这个Observable

      concatMapEager()和concatMap()一样返回的item是有序的,其和concatMap()不一样的是concatMapEager()在执行任务

                                                       转换的时候是以并行处理所有的任务的但是并不是哪个转换任务先执行完就马上返回

                                                      结果让下游进行处理而是要缓存所有执行任务的结果然后严格按照上游Observable发射

                                                      数据item的顺序进行结果的发射来让下游进行处理

    在开发中我们优先使用flatMap(), 如果对返回的数据的顺序有要求可以使用ConcatMap()但是要注意如果如果是比较重的多任务要考虑concatMap()是否合适而concatMapEager()在使用的时候则要考虑到内存的使用情况,因为其内部会缓存任务的返回结果(可能会oom)

     

    本文章参考一下文章:

    https://www.nurkiewicz.com/2017/08/flatmap-vs-concatmap-vs-concatmapeager.html

    https://medium.com/appunite-edu-collection/rxjava-flatmap-switchmap-and-concatmap-differences-examples-6d1f3ff88ee0

     

    展开全文
  • 2、编写一段程序,使用系统调用函数fork( )创建两个子进程,再用系统调用函数signal( )让父进程捕捉信号SIGINT(用kill命令来触发),当捕捉到中断信号后,父进程用系统调用函数kill( )向两个子进程发出信号,子进程...

    2、编写一段程序,使用系统调用函数fork( )创建两个子进程,再用系统调用函数signal( )让父进程捕捉信号SIGINT(用kill命令来触发),当捕捉到中断信号后,父进程用系统调用函数kill( )向两个子进程发出信号,子进程捕捉到父进程发来的信号后,分别输出下列信息后终止:

    	Child process 1 is killed by parent!
    	Child process 2 is killed by parent!
               或者
        Child process 2 is killed by parent!
        Child process 1 is killed by parent!
        父进程等待两个子进程终止后,输出以下信息后终止:
        Parent process exit!
    

    //代码如下

    #include <signal.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    //定义全局变量,否则子进程id号传不进函数
    pid_t pid1,pid2;
    
    //父进程接受信号后向子进程发信号
    void fun(int sig)
    {
    	kill(pid1,SIGUSR1);
    	kill(pid2,SIGUSR2);
    }
    
    //子进程1接收信号后打印
    void fun1(int sig)
    {
    	printf("Child1 process1  is  killed by parent!\n");
    }
    
    //子进程2接收信号后打印
    void fun2(int sig)
    {
    	printf("Child2 process2  is  killed by parent!\n");
    }
    
     int main(int argc(),char *argv[])
    {
    	//产生第一个子进程1
    	pid1 = fork();
    	
    	//父进程接受信号和继续产生一个子进程
    	if(pid1 > 0)
    	{
    		pid2 = fork();
    		//父进程
    		if(pid2 > 0)
    		{
    			signal(SIGINT,fun);
    			wait(NULL);
    			wait(NULL);
    			printf("Parent process exit!\n");
    		}
    		//子进程2接收信号
    		if(pid2 == 0)
    		{
    			signal(SIGUSR2,fun2);
    			pause();
    		}
    	}
    	//子进程1接收信号
    	if(pid1 == 0)
    	{
    		signal(SIGUSR1,fun1);
    		pause();
    	}
    	return 0;
    }
    
    

    通过ps -ef查询到父进程id号,在终端通过kill命令向父进程发送信号
    父进程ID号
    发送信号
    运行结果:
    运行结果
    总结:
    本题有几个点需要注意:
    一是不能使用循环来产生子进程,否则不能得到子进程的ID号,就无法使用kill()函数来发送信号
    二是接收子进程的变量要定义为全局变量,因为signal函数(void (*signal(int sig, void (*func)(int)))(int);)中的第二个参数是关联的自定义函数,而这个函数的参数除了信号不能是其他形参,也不可以自己定义,所以需要使用全局变量。

    //还在学习中,如有错误,欢迎指出

    展开全文
  • ajaxStart()方法用于在Ajax请求发出前触发函数,ajaxStop()方法用于在Ajax请求完成后触发函数。它们的调用格式为:$(selector).ajaxStart(function())和$(selector).ajaxStop(function())其中,两个方法中括号都是...
  • 当线程交互时,如果线程对一个同步对象x发出wait()调用请求,那么该线程会暂停执行,被调对象进入等待状态,直到被唤醒或者等待超时。 具体来说sleep()方法和await()方法的区别主要表现在以下几个方面? 原理...
  • session.load()和session.get()区别

    千次阅读 2018-05-23 07:45:40
    get先到缓存中去查如果没有就到DB中去查(即马上发出sql语句)总之如果你确定DB中有这个对象就用load()不确定就用get()这样效率会高
  • Java面试题-sleep()和wait()

    千次阅读 2019-09-23 20:20:59
    4.关于sleep()和wait(),以下描述错误的一项是(D ) A.sleep是线程类(Thread)的方法,wait是Object类的方法; B.sleep不释放对象锁,wait放弃对象锁 C.sleep暂停线程、但监控状态仍然保持,结束后会自动恢复 D....
  • QThread finished()信号 wait()方法

    万次阅读 2015-11-25 09:31:06
    当QThread线程的run()函数return之后,该线程就会发出finished()信号。 但是,有时候,在finished()信号的槽中,发现该线程依然正在运行,即没有真正的finished,通过调研running()方法,或者is...
  • 既然客户对服务器是远程的,所以getRemotePort()得到的是发出请求的客户的端口号。 getLocalPort ():获取的是应用服务器的端口,即该应用的实际端口,无论请求经过了多少代理,转发,getLocalPort只取最后的端口,...
  • 【JavaEE】Servlet的doGet()和doPost()方法

    千次阅读 2017-04-12 15:03:51
    1. doGet()方法:处理客户端发出的HTTP Get请求。 doPost()方法:处理客户端发出的HTTP Post请求。 tips:可以在doPost()方法中调用doGet()方法,反过来也适用哦 doGet()和doPost()可以同时存在,以应对...
  • 【AJAX】使用ajaxStart()和ajaxStop()方法

    千次阅读 2016-04-07 03:16:06
    ajaxStart()方法用于在Ajax请求发出后立即触发的函数,ajaxStop()方法用于在Ajax请求完成后触发函数。 调用格式为: $(selector).ajaxStart(function())和$(selector).ajaxStop(function()) 其中,两个方法中...
  • 由一道关于sleep()和wait()方法的题目展开 关于sleep()和wait(),以下描述错误的一项是: - A sleep是线程类(Thread)的方法,wait是Object类的方法; - B sleep不释放对象锁,wait放弃对象锁 - C sleep暂停线程、...
  • 今天在调试一个程序时,发现调用 SendMessage() 发送的消息,PreTranslateMessage() 接收不到;试了其它两个方法: (1) 换成 PostMessage() 来广播消息,则 PreTranslateMessage() 可以接收到。 (2) 仍然使用 ...
  • wait()也是一种使线程暂停执行的方法,例如,当线程交互时,如果线程对一个同步对象x发出一个wait()调用请求,那么该线程会暂停执行,被调用对象进入等待状态,直到被唤醒或等待时间超时  具体而言,sleep()方法与...
  • 为什么wait()和notify()必须要使用sychronized?如果不用就会报错IllegalMonitorStateException. 首先要明确,wait()和notify()的实现基础是基于对象存在的。那为什么要基于对象存在呢?这里要明确要等,等待的就是...
  • JAVA中socket编程println()和 write()方法

    千次阅读 2015-11-28 13:42:36
    采用基于TCP的c/s类型socket编程,client发出消息,在Server中接收,并且在接收时采用readline()方法时需要注意,readline()方法要读到分隔符才会完成读取操作,因此如果client采用的是write()方法,则需要在write()...
  • 我们常用wait(),notify()和notifyAll()方法来进行线程间通信。...notify()或notifyAll()的调用给一个或多个线程发出通知,告诉它(它们)条件已经发生改变,并且,一旦通知线程离开同步块,所有等待这个对象锁的
  • exit() abort() 区别

    千次阅读 2012-07-27 17:16:16
    exit()函数结束程序,返回一个值给操作系统,告知程序的最后状态。在调用exit()函数之后,控制权会移交给操作系统。... abort()函数会发出一个SIGABRT信号来终止程序的执行。不会调用之前用atexit()函数注册
  • sleep()和wait()方法与对象锁、锁池、等待池

    万次阅读 多人点赞 2017-02-28 20:43:53
    关于sleep()和wait(),以下描述错误的一项是: - A sleep是线程类(Thread)的方法,wait是Object类的方法; - B sleep不释放对象锁,wait放弃对象锁 - C sleep暂停线程、但监控状态仍然保持,结束后会自动...
  • 问题点: 方法发出一个ajax请求,将返回数据返回出去 错误示例: 解决方案: function find_product_count(callback... $.getJSON("/product/findProductCount", {"date": new Date()}, function (data) { console...
  • session的load()方法是加载数据,从数据库中取得数据,session.load(class,i...调用get()方法取得的直接就是对象,在调用get()方法时直接就发出了SQL语句; 而调用load()方法取得的只是对象的一个代理,在调
  • socket关闭之close()和shutdown()的差异

    千次阅读 2016-05-23 21:21:56
    对于一个tcp连接,在c语言里一般有2种方法可以将其关闭:...close() 是针对file的操作 shutdown() 是针对socket的操作 unix系统里socket是一个文件,但文件不一定是一个socket;所以在进入系统调用后和达到协议层前(发出
  • 使用list()方法获取查询结果,每次发出一条查询语句,获取全部数据 使用iterate()方法获取查询结果,先发出一条SQL 语句用来查询满足条件数据的id,然后依次按这些id 查询记录,也就是要执行N+1 条SQL 语句(N 为...
  • 曾看到一篇文章里面写道setInterval()有很多弊端: 1.setInterval对自己调用的代码是否报错漠不关心。即使调用的代码报错了,它依然会持续的调用下去 2.setInterval无视网络延迟。在使用ajax轮询服务器是否有新数据...
  • 为建立连接,必须马上调用connect()如下,由于先调用了WSAASyncSelect(),connect()便是 非阻塞调用.进程发出连接请求后就不管了,当连接建立好后,WINSOCK DLL自动发一条消息给 主窗口函数,以使程序运行下去. connect...
  • sleep()方法和wait()方法问题

    千次阅读 2018-09-19 15:55:49
    选择题: 关于sleep和wait方法,下面描述错误的是( ) A.sleep是线程类Thread的...D.wait后进入等待锁定池,只有针对此对象发出notify方法后获得对象锁进入运行状态。 分析: A选项毋庸置疑肯定是对的。 ...
  • 1、Response.Redirect(): Response.Redirect方法导致浏览器链接到一个指定的URL。当Response.Redirect()方法被调用时,它会创建一个应答,应答头中指出了状态代 码302(表示目标已经改变)以及新的目标URL。...
  • qobject_cast*>(sender())用法

    千次阅读 2016-09-30 14:32:25
    qobject_cast(sender()) 1、当QPushButton发出一个...2、当有多个OBject发出信号时可根据sender()函数判断是哪个对象发出的; eg: mainwindow.cpp #include "mainwindow.h" #include "ui_mainwindow.h" M

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,608
精华内容 22,643
关键字:

发出()