精华内容
下载资源
问答
  • android中直接开线程与使用服务(Service)开线程两种办法都可以执行长时间任务,它们的区别是什么呢?什么时候使用直接开线程,又什么时候启动服务后,再服务中开线程呢?一个service是一个在用户不与你的应用交互时...

    android中直接开线程与使用服务(Service)开线程两种办法都可以执行长时间任务,它们的区别是什么呢?什么时候使用直接开线程,又什么时候启动服务后,再服务中开线程呢?

    一个service是一个在用户不与你的应用交互时依然可以运行于后台的简单组件.所以,只有你需要这样做时才创建一个service.如果你需要执行的工作不在主线程中,但是只有用户在与你的应用交互时才进行,那么你可能应该创建一个新的线程而不是一个service.例如,如果你想播放一些音乐,但是只在你的activity运行时才播放,你应该在onCreate()中创建一个线程,在onStart()运行这个线程,然后在onStop()中停止它.也可以考虑使用AsyncTask或HandlerThread,来代替传统的线程类.

    举例:
    项目1)点按钮开服务,服务中开线程播放map3
    项目2)点按钮开线程播放mp3

    项目3)能通过开辟项目1中的服务播放mp3(服务可以被其它项目直接启动)
    项目3)不能通过开辟项目2中的线程播放mp3(线程不能被其它项目直接启动)

    展开全文
  • Runnable并不一定新开线程

    千次阅读 2014-12-13 18:52:20
    extends Thread一定新开一个线程,但Runnable不一定新开线程(所谓新开线程,指非UI线程): ① 如果是implements Runnable,像extends Thread一样,是新开了线程。 ②如果是匿名Runnable对象new Runnable() {...

    前面谈到过Threads与Runnable的区别,这里再补充一个特殊的区别。

    extends Thread一定新开一个线程,但Runnable不一定新开线程(所谓新开线程,指非UI线程):

    ① 如果是implements Runnable,像extends Thread一样,是新开了线程。

    ②如果是匿名Runnable对象new Runnable() {...},是把Runnable对象以Message形式post到UI线程的Looper里执行。


    1) Runnable 并不一定是新开一个线程,比如下面的调用方法就是运行在UI主线程中的:

    Handler mHandler=new Handler();
    mHandler.post(new Runnable(){
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    	}
    });

    官方对这个方法的解释如下,注意其中的:“The runnable will be run on the user interface thread. ”

    我们可以通过调用handler的post方法,把Runnable对象(一般是Runnable的子类)传过去;handler会在looper中调用这个Runnable的Run方法执行。

     mHandler.post(new Runnable(){......}) 好像是new 了一个 interface, 其实是new的一个实现Runnable的匿名内部类(Inner Anonymous Class),这是很简练的写法!

    上面的代码可以看成是: new anonymousClass() implement Runnable{......}

    Runnable是一个接口,不是一个线程,一般要开线程的类会implements Runnable。

    所以:

    如果我们使用匿名内部类,则是运行在UI主线程的;

    如果我们使用implements这个Runnable接口的线程类,则是运行在另一个新线程的。


    2) View也可以post一个Runnable对象到UI线程你去执行:

    View.post(Runnable)

    boolean android.view.View.post(Runnable action)

    Causes the Runnable to be added to the message queue. The runnable will be run on the user interface thread.

    Parameters: 
    action The Runnable that will be executed. 
    Returns: 
    Returns true if the Runnable was successfully placed in to the message queue. Returns false on failure, usually because the looper processing the message queue is exiting.

    具体来说,View.post(Runnable)这个函数的工作原理如下:

    在post(Runnable action)方法里,View获得当前线程(即UI线程)的Handler,然后将action对象post到Handler里。在Handler里,它将传递过来的action对象包装成一个Message(Message的callback为action,即通过Message可以回调action),然后将其投入UI线程的消息循环中。在Handler再次处理该Message时,有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法。而此时,已经路由到UI线程里,因此,我们可以在这个Runnable action里毫无顾虑的来更新UI,比如调用findViewById或者TextView.setText等

    如下图,前面看到的代码,我们这里Message的callback为一个Runnable的匿名内部类

    这种情况下,由于不是在新的线程中使用,而是在UI线程,所以千万别做复杂的计算逻辑。

    image

    参考资料:

    Android中的Handler, Looper, MessageQueue和Thread 
    http://www.cnblogs.com/xirihanlin/archive/2011/04/11/2012746.html

    Android系列之Message机制的灵活应用 
    http://tech.ddvip.com/2010-07/1280393505158258_3.html



    展开全文
  • 二、在Service中新开线程和直接新开线程的区别 (1)若我们直接在Activity中新开一条线程来做耗时操作,当该Activity退出到桌面或其他情况时将成为一个 背景进程 。 (2)若我们在Service中新启动线程...

    FBI Warning:欢迎转载,但请标明出处:http://blog.csdn.net/codezjx/article/details/8854507,未经本人同意请勿用于商业用途,感谢支持!


    为了了解这两者的区别,我们首先来了解一下Android的进程与生命周期


    一、Android的进程与生命周期:

    Android系统会尽可能长的延续一个应用程序进程,但在内存过低的时候,仍然会不可避免需要移除旧的进程。为决定保留或移除一个进程,Android将每个进程都放入一个“重要性层次”中,依据则是它其中运行着的组件及其状态。重要性最低的进程首先被消灭,然后是较低的,依此类推。重要性共分五层,依据重要性列表如下:

    (1)前台进程

    是用户操作所必须的,任一时间下,仅有少数进程会处于前台,这样的进程拥有一个在屏幕上显示并和用户交互的 activity 或者它的一个IntentReciver 正在运行。仅当内存实在无法供给它们维持同时运行时才会被杀死。一般来说,在这种情况下,设备依然处于使用虚拟内存的状态,必须要杀死一些前台进程以用户界面保持响应。

    (2)可视进程

    没有前台组件,但仍可被用户在屏幕上所见。当满足如下任一条件时,进程被认为是可视的:

    ●它包含着一个不在前台,但仍然为用户可见的activity(它的onPause()方法被调用)。这种情况可能出现在以下情况:比如说,前台activity是一个对话框,而之前的Activity位于其下并可以看到。

    它包含了一个绑定至一个可视的activity的服务。

     可视进程依然被视为是很重要的,非到不杀死它们便无法维持前台进程运行时,才会被杀死。

    (3)服务进程

    是由startService() 方法启动的服务,它不会变成上述两类。尽管服务进程不会直接为用户所见,但它们一般都在做着用户所关心的事情(比如在后台播放mp3或者从网上下载东西)。所以系统会尽量维持它们的运行,除非系统内存不足以维持前台进程和可视进程的运行需要。

    (4)背景进程

    包含目前不为用户所见的activity(Activity对象的onStop() 方法已被调用)。这些进程与用户体验没有直接的联系,可以在任意时间被杀死以回收内存供前台进程、可视进程以及服务进程使用。一般来说,会有很多背景进程运行,所以它们一般存放于一个LRU(最后使用)列表中以确保最后被用户使用的activity最后被杀死。如果一个activity正确的实现了生命周期方法,并捕获了正确的状态,则杀死它的进程对用户体验不会有任何不良影响。

    (5)空进程

    不包含任何活动应用程序组件。这种进程存在的唯一原因是做为缓存以改善组件再次于其中运行时的启动时间。系统经常会杀死这种进程以保持进程缓存和系统内核缓存之间的平衡。


    Android会依据进程中当前活跃组件的重要程度来尽可能高的估量一个进程的级别。比如说,如果一个进程中同时有一个服务和一个可视的activity,则进程会被判定为可视进程,而不是服务进程。

    此外,一个进程的级别可能会由于其它进程依赖于它而升高。一个为其它进程提供服务的进程级别永远高于使用它服务的进程。比如说,如果A进程中的内容提供者为进程B中的客户端提供服务,或进程A中的服务为进程B中的组件所绑定,则A进程最低也会被视为与进程B拥有同样的重要性


    二、在Service中新开线程和直接新开线程的区别

    (1)若我们直接在Activity中新开一条线程来做耗时操作,当该Activity退出到桌面或其他情况时将成为一个背景进程

    (2)若我们在Service中新启动线程,则此时Android会依据进程中当前活跃组件重要程度,将其判断为服务进程,优先级比(1)高。


    三、总结:

    因为运行着一个服务的进程重要级别总高于一个背景Activity,所以一个Activity以启动一个服务的方式启动一个长时间运行过程比简单的衍生一个线程来处理要好。尤其是当处理过程比Activity本事存在的时间要长的情况之下。我们以背景音乐播放和上传一个相机拍摄的照片至网站上为例。使用服务则不论Activity发送何种情况,都至少可以保证操作拥有“服务进程”的权限。在内存紧缺的情况下,能保证其不那么容易被杀死。这也正是广播接收器使用服务,而不是线程来处理耗时任务的原因。



    展开全文
  • fork/join 和开线程数量

    千次阅读 2019-01-18 13:44:31
    //四个线程同时去执行 ForkJoinPool myPool = new ForkJoinPool(4); myPool.submit(() -> {}) 打开的线程数 public class ThreadPoolHelper { public static ThreadPool instance; private ...
    //四个线程同时去执行
    ForkJoinPool myPool = new ForkJoinPool(4);
    myPool.submit(() -> {})

    打开的线程数

    public class ThreadPoolHelper {
    
        public static ThreadPool instance;
        private ThreadPoolExecutor longExecutor; // 耗时比较长的线程池   用来请求网络
        private ThreadPoolExecutor shortExecutor; // 比较短的线程池    用来加载本地数据
    
        // 获取单例的线程池对象
        public static ThreadPool getInstance() {
            if (instance == null) {
                synchronized (ThreadPoolHelper.class) {
                    if (instance == null) {
                        int cpuNum = Runtime.getRuntime().availableProcessors();// 获取处理器数量
                        int threadNum = cpuNum * 2 + 1;// 根据cpu数量,计算出合理的线程并发数
                        instance = new ThreadPool(threadNum-1, threadNum, Integer.MAX_VALUE);//默认是双核的cpu 每个核心走一个线程 一个等待线程
                    }
                }
            }
            return instance;
        }
    
        public static class ThreadPool {
            private ThreadPoolExecutor mExecutor;
            private int corePoolSize;// 核心线程数
            private int maximumPoolSize;// 最大线程数
            private long keepAliveTime;// 闲置线程存活时间
    
            private ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
                this.corePoolSize = corePoolSize;
                this.maximumPoolSize = maximumPoolSize;
                this.keepAliveTime = keepAliveTime;
            }
    
            public void execute(Runnable runnable) {
                if (runnable == null) {
                    return;
                }
                if (mExecutor == null) {
                    mExecutor = new ThreadPoolExecutor(corePoolSize,// 核心线程数
                            maximumPoolSize, // 最大线程数
                            keepAliveTime, // 闲置线程存活时间
                            TimeUnit.MILLISECONDS,// 时间单位
                            new LinkedBlockingDeque<Runnable>(Integer.MAX_VALUE),// 线程队列
                            Executors.defaultThreadFactory(),// 线程工厂
                            new ThreadPoolExecutor.AbortPolicy() {// 队列已满,而且当前线程数已经超过最大线程数时的异常处理策略
                                @Override
                                public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                                    super.rejectedExecution(r, e);
                                }
                            }
                    );
                }
                mExecutor.execute(runnable);
            }
    
    
            // 从线程队列中移除对象
            public void cancel(Runnable runnable) {
                if (mExecutor != null) {
                    mExecutor.getQueue().remove(runnable);
                }
            }
        }
    
    
        /**
         * 测试使用方法
         */
        @Test
        public void test(){
    
            ThreadPoolHelper.getInstance().execute(new Runnable(){
                public void run() {
                    //这里编写处理业务代码
    
                }
    
            });
        }
    展开全文
  • OC开线程的三种方式

    千次阅读 2018-01-25 09:19:49
    第一种NSThread   //NSThread 方法1 需要手动start];  NSThread *thread=[[NSThread alloc]initWithTarget:self selector:@selector(threadRun:) ... thread.name =@"线程1";  //优先级 0.0-1.0 默认0
  • 然后我再在每个thread中再3个线程, thread-1中开启thread-11,thread-12,thread-13; thread-2中开启thread-21,thread-22,thread-23; thread-3中开启thread-31,thread-32,thread-33; 1、这样可以么? 2、会...
  • JVM内存区域,开线程影响哪块内存

    千次阅读 2019-07-19 22:57:49
    概括地说来:JVM初始运行的时候都会分配好Method Area(方法区)和Heap(堆),而JVM 每遇到一个线程,就为其分配一个Program Counter Register(程序计数器), VM Stack(虚拟机栈)和Native Method Stack (本地...
  • 在Unity实现Socket通信,当开了一个线程后,如果你没在关闭程序前关闭该线程,会发生你重新运行后unity卡死的现象: 要解决只要关闭线程就好了。 实现:在对象销毁(OnDestroy())前 public void killTreath() ...
  • 现在项目中有这样一个需求,政府需要对辖区内的...需要中断这个线程,我在开线程的时候已经有了线程Id,看网上说ThreadGroup是可以的,但是已经被废弃了,不推荐使用,不知道有没有其他办法中断某个具体的线程的,求教
  • 线程

    千次阅读 多人点赞 2021-04-14 14:24:30
    线程一、进程、线程1.1 进程1.2 线程1.3 java程序的进程和线程1.4 主线程、子线程 一、进程、线程 java语言之所以有多线程,目的是提高程序的运行效率。 1.1 进程 进程是一个应用程序(一个进程是一个软件...
  • Python开启线程,函数中开线程

    千次阅读 2017-06-09 15:12:57
    我这里遇到的情形是前面取数据后面存到mysql,发现单线程效率很低,改为取数据后开线程存到mysql 开启线程之后性能提升一倍,同时用信号量做线程同步,控制数据库同时连接数 这里只是简单的一个demo,主要是开线程...
  • 线程的正确打开方式

    千次阅读 2020-08-27 19:08:23
    线程作为操作系统调度的最小单元,多个线程能够同时执行,这将 显著提升程序性能,在多核环境中表现得更加明显。但是,过多地创建线程和对线程的不当管 理也容易造成问题。本章将着重介绍Java并发编程的基础知识,从...
  • android 线程里面再新的的线程

    千次阅读 2016-03-04 11:36:18
    当 一个线程里面另外一个线程的时候,需要注意的地方,例如:  @Override  public void run() {  // TODO Auto-generated method stub  mTimeCount++;  mProgres
  • 开启线程第一种方式: public class test { public static void main(String[] args) { Thread t1 = new MyThread();... // 开线程 for (int i = 0; i ; i++) System.out.println(Thread.currentThrea
  • 进程和线程一样,可以多个。进程是静态的,一个进程里可以有多个线程。   起动线程有两个方法:一个是接口RUNABLE,一个是继承THERAD   public class testthread{ public static void main(){ Runner1 r = ...
  • 一、Python多进程多线程 关于python多进程多线程的相关基础知识,在我之前的博客有写过,并且就关于python多线程的GIL锁问题,也在我的一篇博客中有相关的解释。 为什么python多线程在面对IO密集型任务的时候会产生...
  • Python 多进程下线程满负荷工作

    千次阅读 2018-08-28 16:58:51
    本文只是写一个例子,实现了多个进程,每个进程下面线程,每个进程执行单独一个任务,并行执行,进程下的多线程执行任务,并发执行,有效利用CPU资源. import multiprocessing import threading import time def m...
  • 多核CPU几个线程最好

    千次阅读 2015-05-18 10:03:37
    IO开销较多的应用其CPU线程等待时间会比较长,所以线程数量可以的多一些,相反则线程数量要少一些,其实有两种极端,纯IO的应用,比如proxy,则线程数量可以到非常大(实在太大了则需要考虑线程切换的开销)
  • Java:多线程:到底什么时候该用多线程

    万次阅读 多人点赞 2018-09-30 16:27:29
    一、高并发 系统接受实现多用户多请求的高并发时,通过多线程来实现。... 这时候可以开线程把花大量时间处理的任务放在线程处理,这样线程在后台处理时,主程序也可以继续执行下去,用户就不需要等待。线...
  • # 多个线程 是否跟CPU有关? 我本机60个线程看起来没有起多大作用,这是怎么回事 求大神解答
  • 一个并发程序多少线程合适?

    万次阅读 2015-10-05 19:16:20
    最近在和朋友讨论的过程中,朋友说线程开得多性能好,理由是系统中已经有成百上千的线程,并发程序线程越多分配到CPU的概率越高。我不认可该观点,下面来验证。 最好起CPU核心数量*2 个线程 或者 CPU核心数量*...
  • 进程-线程-多线程 1、进程(process) 狭义定义:进程就是一段程序的执行过程 简单的来讲进程的概念主要有两点: 第一,进程是一个实体。每一个进程都有它自己的地址空间,一般情况下,包括文本区域(text region)...
  • OpenCV+Qt多线程打开多摄像头

    千次阅读 多人点赞 2018-12-03 13:34:46
    本例程打开四个USB摄像头,三个型号一样,另一个型号不一样,原本想打开四个型号一样的,但是不知道为什么有一个就是打不,现在还在查找原因。下面结合代码来讲解。 头文件thread_cam.h中定义了子线程类thread_...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • 什么是多线程?如何实现多线程

    万次阅读 多人点赞 2019-04-09 09:53:36
    【转】什么是线程安全?怎么实现线程安全?什么是进程?什么是线程?什么是线程安全?添加一个状态呢?如何确保线程安全?synchronizedlock 转自:https://blog.csdn.net/csdnnews/article/details/82321777 什么是...
  • 因为Android后期版本对主线程不允许运行耗时操作的规定,你新开线程的几率比起java,大大的提升了。 这样就会碰到一个问题,当你开启线程,在线程没有运行完的时候,想要结束这个线程,要怎么操作呢? 标志位结束...
  • 最近在做一个项目,项目要用到多线程,但是我不知道应该多少个线程为好,听同事介绍说这种情况可以做一个压力测试,您能帮我解释一下压力测试吗?除此之外还有其他的办法吗?
  • c++主线程和子线程

    千次阅读 2020-01-29 10:04:08
    c++主线程和子线程 ...在一个线程中开启另外一个新线程,则新开线程称为该线程的子线程,子线程初始优先级与父线程相同。不过主线程先启动占用了cpu资源,如果存在主线程和子线程争抢cpu执行权的话,看运气,谁...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 695,889
精华内容 278,355
关键字:

怎么开线程