Android开发（27）
new Thread().start()的弊病
因为不能在UI中执行耗时操作，所以需要用到子线程，在平常使用的过程中，常常会使用下面这种方式执行。
new Thread(new Runnable() {
public void run() {
}).start();
使用这种方式执行子线程存在如下三个弊病：
在操作系统中，大量的线程存在，会影响性能，因为CPU在线程之间的切换也会消耗资源，同时更多的线程对象也会占用更多的线程空间（每个线程需要大约1M的内存）。所以需要手动或者自动（常为cpu核心个数+1）指定线程的个数，减少资源抢占。
一个线程对象的生命周期可以分为以下三个阶段 1. 对象创建，分配资源—T1 2. 对象使用，执行任务—T2 3. 对象销毁，GC回收—T3 对唯一一个需要执行的任务来说，他的总执行时间是T=T1+T2+T3。但是对多个任务，线程只是任务的载体，可以利用现有存活的线程资源执行。T1和T3消耗的时间可以优化掉，最终执行时间T≈T2；
匿名对象，无法进行更多操作
通过匿名类的方式无法得到当前任务执行状态，通过Future接口，可以得到任务是否执行完成，是否已经取消，取消任务。
public interface Future&V& {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
ThreadPoolExecutor 线程池
构造函数：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue&Runnable& workQueue, ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
corePoolSize
the number of threads to keep in the pool, even if they are idle, unless allowCoreThreadTimeOut is set
核心线程数，即使限制也不会回收，但是可以使用allowCoreThreadTimeOut配置它被回收
maximumPoolSize
maximumPoolSize the maximum number of threads to allow in the pool
线程池能够容纳的最大线程数，当活动线程数达到这个数值后，后序的新任务将会被阻塞。
the maximum number of threads to allow in the pool keepAliveTime when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.
非核心线程的等待超时时长，非核心线程限制超过这个时长会被回收。
unit the time unit for the keepAliveTime argumentkeepAliveTime
// 常用单位毫秒、秒、小时
TimeUnit.MILLISECONDS
TimeUnit.SECONDS
TimeUnit.HOURS
the queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method
线程池的任务队列，只有Runnable类型的对象才会 提交到这里面。
threadFactory
threadFactory the factory to use when the executor creates a new threadthreadFactory
是一个接口
public interface ThreadFactory {
Thread newThread(Runnable r);
接口只实现一个方法，创建一个线程，`threadFactory`就是专为线程池创建线程。
the handler to use when execution is blocked because the thread bounds and queue capacities are reached。
RejectedExecutionHandler提供一个异常处理机制
private static final int CPU_COUNT = Runtime.getRuntime()
.availableProcessors();
private static final int MAX_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final ThreadFactory mThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "Task:" + mCount.getAndIncrement());
private static final BlockingQueue&Runnable& sPoolWorkQueue = new LinkedBlockingQueue&Runnable&(
public static final Executor threadPools = new ThreadPoolExecutor(
CPU_COUNT + 1, MAX_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS,
sPoolWorkQueue);
核心线程为CPU核心数+1
最大线程为CPU核心数*2+1
核心线程长期存活，非核心线程等待时间为1s
任务队列为128
任务执行流程：
1. 如果线程池中核心线程数未满，直接开启一个核心线程
2. 如果核心线程已满，就将任务展存在执行队列，队列可以配置执行顺序（FIFO，LIFO）
3. 如果workQueue也满了，但是最大线程数未满，直接开启一个非核心线程执行任务，非核心线程有超时时间，闲置超过超时时间就回收。
4. 如果线程池中的存活线程数量已经超过了，最大线程数，抛出异常。
线程池分类-Executors工具类
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，完全不创建非核心线程。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue&Runnable&());
newCachedThreadPool
一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。没有核心线程，有一个近乎于无限大的线程池，可以创建非常多的非核心线程。特别适合执行大量的消耗时间少的任务。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue&Runnable&());
newScheduledThreadPool—ScheduledThreadPoolExecutor
一个定长线程池，支持定时及周期性任务执行。
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
使用方法，如下是ScheduledThreadPoolExecutor的成员方法
public &V& ScheduledFuture&V& schedule(Callable&V& callable,long delay, TimeUnit unit);
delay-当前任务延迟执行时间
public ScheduledFuture&?& scheduleAtFixedRate(Runnable command,long initialDelay, long period,TimeUnit unit);
initialDelay—第一个任务延迟执行时间
period—两次任务执行之间的时间间隔也就是可以使用这个封装实现，每隔一段时间执行一个任务，使用它可以实现推送服务的心跳连接。
newSingleThreadExecutor
线程池内部只有一个核心线程，确保所有任务都在同一个线程中按顺序执行。这样的话统一所有的外界任务到同一个线程，任务之间不需要处理线程同步的问题。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue&Runnable&()));
线程可控—Callable、Future、FutureTask
回到开始说的那个问题：匿名对象，无法进行更多操作，通过匿名类的方式无法得到当前任务执行状态，通过Future接口，可以得到任务是否执行完成，是否已经取消，取消任务。要解决这个问题，在线程池里创建了三个类型：
通过上面介绍的线程池，得到一个ExecutorService
public interface ExecutorService extends Executor {
&T& Future&T& submit(Callable&T& task);
&T& Future&T& submit(Runnable task, T result);
Future&?& submit(Runnable task);
继承一个Executor接口
public interface Executor {
void execute(Runnable command);
发现Callable和Runnable都是ExecutorService实例化对象支持的类型，但是Callable包含一个泛型，同时会返回一个Future对象参看Callable实现
public interface Callable&V& {
* Computes a result, or throws an exception if unable to do so.
computed result
Exception if unable to compute a result
V call() throws E
public interface Runnable {
* Starts executing the active part of the class' code. This method is
* called when a thread is started that has been created with a class which
* implements {@code Runnable}.
public void run();
发现Runnable和Callable&V&极其相似，只是后者是一个带泛型，事实上这两个接口再使用上也是很相似的，泛型里面携带的其实是任务的执行结果。
查看实现代码：
public interface Future&V& {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionE
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutE
cancel() 方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。
参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
isCancelled() 方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone() 方法表示任务是否已经完成，若任务完成，则返回true；
get() 方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。也就是说Future提供三种功能
获取当前任务执行状态
判断任务是否执行完成
得到任务执行结果
FutureaTask
因为Future是个接口，所以需要一个具体的实现—FutureTask
public class FutureTask&V& implements RunnableFuture&V& {}
public interface RunnableFuture&V& extends Runnable, Future&V& {
void run();
FutureTask同时实现了Runnable和Future，对比刚才的Callable+返回Futrue的实现形式，这个类型其实就是Callable+Future的组合实现。取消一个任务：
void test() {
ExecutorService pool = Executors.newFixedThreadPool(2)
Callable&String& s = new Callable&String&() {
public String call() throws Exception {
System.out.println("test")
return "true"
Future&String& f = pool.submit(s)
System.out.println(f.isCancelled())
System.out.println(f.isDone())
f.cancel(true)
获取执行结果：
private void init() {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future&Integer& result = executor.submit(task);
executor.shutdown();
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
System.out.println("主线程在执行任务");
System.out.println("task运行结果" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
System.out.println("所有任务执行完毕");
class Task implements Callable&Integer& {
public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(3000);
int sum = 0;
for (int i = 0; i & 100; i++)
return sum;
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：71156次
积分：1338
积分：1338
排名：千里之外
原创：52篇
评论：19条
(1)(8)(15)(28)(1)(3)西西软件下载最安全的下载网站、值得信赖的软件下载站！
→ Android中UI线程与后台线程交互设计的5种方法
1.0.6 官方最新版
类型：图像浏览大小：13.0M语言：英文 评分：4.2
我想关于这个话题已经有很多前辈讨论过了。今天算是一次学习总结吧。在android的设计思想中，为了确保用户顺滑的操作体验。一些耗时的任务不能够在UI线程中运行，像访问网络就属于这类任务。因此我们必须要重新开启一个后台线程运行这些任务。然而，往往这些任务最终又会直接或者间接的需要访问和控制UI控件。例如访问网络获取数据，然后需要将这些数据处理显示出来。就出现了上面所说的情况。原本这是在正常不过的现象了，但是android规定除了UI线程外，其他线程都不可以对那些UI控件访问和操控。为了解决这个问题，于是就引出了我们今天的话题。Android中后台线程如何与UI线程交互。据我所知android提供了以下几种方法，用于实现后台线程与UI线程的交互。1、handler2、Activity.runOnUIThread(Runnable)3、View.Post(Runnable)4、View.PostDelayed(Runnabe,long)5、AsyncTask方法一：handlerhandler是android中专门用来在线程之间传递信息类的工具。要讲明handler的用法非常简单，但是我在这里会少许深入的讲一下handler的运行机制。为了能够让handler在线程间传递消息，我们还需要用到几个类。他们是looper，messageQueue，message。这里说的looper可不是前段时间的好莱坞大片环形使者，他的主要功能是为特定单一线程运行一个消息环。一个线程对应一个looper。同样一个looper对应一个线程。这就是所谓的特定单一。一般情况下，在一个线程创建时他本身是不会生产他特定单一的looper的（主线程是个特例）。因此我们需要手动的把一个looper与线程相关联。其方法只需在需要关联的looper的线程中调用Looper.prepare。之后我们再调用Looper.loop启动looper。说了这么多looper的事情，到底这个looper有什么用哪。其实之前我们已经说到了，他是为线程运行一个消息环。具体的说，在我们将特定单一looper与线程关联的时候，looper会同时生产一个messageQueue。他是一个消息队列，looper会不停的从messageQuee中取出消息，也就是message。然后线程就会根据message中的内容进行相应的操作。那么messageQueue中的message是从哪里来的哪？那就要提到handler了。在我们创建handler的时候，我们需要与特定的looper绑定。这样通过handler我们就可以把message传递给特定的looper，继而传递给特定的线程。在这里，looper和handler并非一一对应的。一个looper可以对应多个handler，而一个handler只能对应一个looper（突然想起了一夫多妻制，呵呵）。这里补充一下，handler和looper的绑定，是在构建handler的时候实现的，具体查询handler的构造函数。在我们创建handler并与相应looper绑定之后，我们就可以传递message了。我们只需要调用handler的sendMessage函数，将message作为参数传递给相应线程。之后这个message就会被塞进looper的messageQueue。然后再被looper取出来交给线程处理。这里要补充说一下message，虽然我们可以自己创建一个新的message，但是更加推荐的是调用handler的obtainMessage方法来获取一个message。这个方法的作用是从系统的消息池中取出一个message，这样就可以避免message创建和销毁带来的资源浪费了（这也就是算得上重复利用的绿色之举了吧）。突然发现有一点很重要的地方没有讲到，那就是线程从looper收到message之后他是如何做出响应的嘞。其实原来线程所需要做出何种响应需要我们在我们自定义的handler类中的handleMessage重构方法中编写。之后才是之前说的创建handler并绑定looper。好吧说的可能哟点乱，总结一下利用handler传递信息的方法。假设A线程要传递信息给B线程，我们需要做的就是1、在B线程中调用Looper.prepare和Looper.loop。（主线程不需要）2、 编写Handler类，重写其中的handleMessage方法。3、创建Handler类的实例，并绑定looper4、调用handler的sentMessage方法发送消息。到这里，我们想handler的运行机制我应该是阐述的差不多了吧，最后再附上一段代码，供大家参考。&1&public&class&MyHandlerActivity&extends&Activity&{
&2&&&&&&TextView&textV
&3&&&&&&MyHandler&myH
&5&&&&&&protected&void&onCreate(Bundle&savedInstanceState)&{
&6&&&&&&&&&&super.onCreate(savedInstanceState);
&7&&&&&&&&&&setContentView(R.layout.handler);
&9&&&&&&&&&&//实现创建handler并与looper绑定。这里没有涉及looper与
&&&&&&&&&&&&//线程的关联是因为主线程在创建之初就已有looper
10&&&&&&&&&&myHandler=MyHandler(MyHandlerActivitythis.getMainLooper());
11&&&&&&&&&&textView&=&(textView)&findViewById(R.id.textView);
12&&&&&&&&&
13&&&&&&&&&&MyThread&m&=&new&MyThread();
14&&&&&&&&&&new&Thread(m).start();
18&&&&&&class&MyHandler&extends&Handler&{
19&&&&&&&&&&public&MyHandler()&{
20&&&&&&&&&&}
22&&&&&&&&&&public&MyHandler(Looper&L)&{
23&&&&&&&&&&&&&&super(L);
24&&&&&&&&&&}
26&&&&&&&&&&//&必须重写这个方法，用于处理message
27&&&&&&&&&&@Override
28&&&&&&&&&&public&void&handleMessage(Message&msg)&{
29&&&&&&&&&&&&&&//&这里用于更新UI
30&&&&&&&&&&&&&&Bundle&b&=&msg.getData();
31&&&&&&&&&&&&&&String&color&=&b.getString(&color&);
32&&&&&&&&&&&&&&MyHandlerActivity.this.textView.setText(color);
33&&&&&&&&&&}
36&&&&&&class&MyThread&implements&Runnable&{
37&&&&&&&&&&public&void&run()&{
38&&&&&&&&&&&&&&//从消息池中取出一个message
39&&&&&&&&&&&&&&Message&msg&=&myHandler.obtainMessage();
40&&&&&&&&&&&&&&//Bundle是message中的数据
41&&&&&&&&&&&&&&Bundle&b&=&new&Bundle();
42&&&&&&&&&&&&&&b.putString(&color&,&&我的&);
43&&&&&&&&&&&&&&msg.setData(b);
44&&&&&&&&&&&&&&//传递数据
45&&&&&&&&&&&&&&myHandler.sendMessage(msg);&//&向Handler发送消息,更新UI
46&&&&&&&&&&}
47&&&&&&}方法二：Activity.runOnUIThread(Runnable)&这个方法相当简单，我们要做的只是以下几步1、编写后台线程，这回你可以直接调用UI控件2、创建后台线程的实例3、调用UI线程对应的Activity的runOnUIThread方法，将后台线程实例作为参数传入其中。注意：无需调用后台线程的start方法方法三：View.Post(Runnable)&该方法和方法二基本相同，只是在后台线程中能操控的UI控件被限制了，只能是指定的UI控件View。方法如下1、编写后台线程，这回你可以直接调用UI控件，但是该UI控件只能是View2、创建后台线程的实例3、调用UI控件View的post方法，将后台线程实例作为参数传入其中。方法四：View.PostDelayed(Runnabe,long)该方法是方法三的补充，long参数用于制定多少时间后运行后台进程&方法五：AsyncTaskAsyncTask是一个专门用来处理后台进程与UI线程的工具。通过AsyncTask，我们可以非常方便的进行后台线程和UI线程之间的交流。那么AsyncTask是如何工作的哪。AsyncTask拥有3个重要参数1、Params&2、Progress3、ResultParams是后台线程所需的参数。在后台线程进行作业的时候，他需要外界为其提供必要的参数，就好像是一个用于下载图片的后台进程，他需要的参数就是图片的下载地址。Progress是后台线程处理作业的进度。依旧上面的例子说，就是下载图片这个任务完成了多少，是20%还是60%。这个数字是由Progress提供。Result是后台线程运行的结果，也就是需要提交给UI线程的信息。按照上面的例子来说，就是下载完成的图片。AsyncTask还拥有4个重要的回调方法。1、onPreExecute2、doInBackground3、onProgressUpdate4、onPostExecuteonPreExecute运行在UI线程，主要目的是为后台线程的运行做准备。当他运行完成后，他会调用doInBackground方法。doInBackground运行在后台线程，他用来负责运行任务。他拥有参数Params，并且返回Result。在后台线程的运行当中，为了能够更新作业完成的进度，需要在doInbackground方法中调用PublishProgress方法。该方法拥有参数Progress。通过该方法可以更新Progress的数据。然后当调用完PublishProgress方法，他会调用onProgressUpdate方法用于更新进度。onProgressUpdate运行在UI线程，主要目的是用来更新UI线程中显示进度的UI控件。他拥有Progress参数。在doInBackground中调用PublishProgress之后，就会自动调onProgressUpdate方法onPostExecute运行在UI线程，当doInBackground方法运行完后，他会调用onPostExecute方法，并传入Result。在onPostExecute方法中，就可以将Result更新到UI控件上。明白了上面的3个参数和4个方法，你要做的就是1、编写一个继承AsyncTask的类，并声明3个参数的类型，编写4个回调方法的内容。2、然后在UI线程中创建该类（必须在UI线程中创建）。3、最后调用AsyncTask的execute方法，传入Parmas参数（同样必须在UI线程中调用）。这样就大功告成了。另外值得注意的2点就是，千万不要直接调用那四个回调方法。还有就是一个AsyncTask实例只能执行一次，否则就出错哦。以上是AsyncTask的基本用法，更加详细的内容请参考android官方文档。最后附上一段代码，供大家参考。&1&private&class&DownloadFilesTask&extends&AsyncTask&URL,&Integer,&Long&&
&2&//在这里声明了Params、Progress、Result参数的类型
&4&&&&&//因为这里不需要使用onPreExecute回调方法，所以就没有加入该方法
&6&&&&&//后台线程的目的是更具URL下载数据
&7&&&&&&protected&Long&doInBackground(URL...&urls)&{
&8&&&&&&&&&&int&count&=&urls.//urls是数组，不止一个下载链接
&9&&&&&&&&&&long&totalSize&=&0;//下载的数据
10&&&&&&&&&&for&(int&i&=&0;&i&&&&i++)&{
11&&&&&&&&&&&&&&//Download是用于下载的一个类，和AsyncTask无关，大家可以忽略他的实现
12&&&&&&&&&&&&&&totalSize&+=&Downloader.downloadFile(urls[i]);
13&&&&&&&&&&&&&&publishProgress((int)&((i&/&(float)&count)&*&100));//更新下载的进度
14&&&&&&&&&&&&&&//&Escape&early&if&cancel()&is&called
15&&&&&&&&&&&&&&if&(isCancelled())&
16&&&&&&&&&&}
17&&&&&&&&&&return&totalS
20&&&&&&//更新下载进度
21&&&&&&protected&void&onProgressUpdate(Integer...&progress)&{
22&&&&&&&&&&setProgressPercent(progress[0]);
25&&&&&&//将下载的数据更新到UI线程
26&&&&&&protected&void&onPostExecute(Long&result)&{
27&&&&&&&&&&showDialog(&Downloaded&&&+&result&+&&&bytes&);
30&有了上面的这个类，接下你要做的就是在UI线程中创建实例，并调用execute方法，传入URl参数就可以了。这上面的5种方法各有优点。但是究其根本，其实后面四种方法都是基于handler方法的包装。在一般的情形下后面四种似乎更值得推荐。但是当情形比较复杂，还是推荐使用handler。最后补充一下，这是我的第一篇博客。存在很多问题请大家多多指教。尤其是文中涉及到内容，有严重的技术问题，大家一定要给我指明啊。拜托各位了。
04-2504-2504-2504-2104-1504-1504-1304-1304-1204-08
阅读本文后您有什么感想? 已有23人给出评价!
名称大小下载两个线程交替执行 android 为何线程没有 - 无忧知识网
有关“两个线程交替执行 android 为何线程没有”的文章
近期网友提出“两个线程交替执行 android 为何线程没有”等问题，无忧知识网在网络上认真整理了“两个线程交替执行 android 为何线程没有”的一些信息，请注意，文中内容不代表本站的真正观点，不要相信各种联系方式。下面是本网整理的关于“两个线程交替执行 android 为何线程没有”的一些基本知识：
题目：// 创建一个可固定线程数的线程池 ExecutorService pool = Executors.newFixedThreadPool(2); // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); // 将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.close()上面定义了一个固定线程数的线程池，现在要实现绝对的线程执行顺序(同步执行)（先执行线程1,然后执行线程2）,这个怎么实现了？有什么好的解决方?fortianwei huangtao zjw681691 sk. futurexiong haoliuyou su1216 cui 六号 hehui1860参考：&&&&Thread：List list task自己定义数据结构run(){while(true){if(list.isEmpty){ wait();} else { 读取list的第一个值，获取task的参数执行耗时作}}再写一个add方法add(Task task){list.add(task);notify();} 查看>>
问题：android 为何线程没有启动
回答：主线程会在运行apk时自动启动，如果你打开个新的线程，必须要在想打开线程的时候调用线程的.start（）方法
问题：什么是超线程,超线程CPU导机怎么办
回答：什么是超线程? 超线程技术就是利用特殊的硬件指令，把两个逻辑内核模拟成两个物理芯片，让单个处理器都能使用线程级并行计算，进而兼容多线程作系统和软件，减少了CPU的闲置时间，提高的CPU的运行效率。 超线程CPU导致电脑机怎么办? 使用超线程CPU的电脑，如果用WinXP集成的IE6浏览网页，常会出现机现象，解决办法有三种： 1.在BIOS里关闭超线程技术； 2.使用其它浏...
问题：重装系统后CPU由四线程变双线程了
回答：...月前买了台本，CPU是i5 430M，当时预装的是Win7 64位的普通版，打开任务管理器看CPU是四线程的。上个月重装了Win7 32位，昨天用软件查看显示是核心2，线程2。但我到网上查了查发现I5 430M，物理核心是2，线程应该为4埃不知道这个问题在哪里?如何解决?龚师傅：这可能是由于所安装的Win7版本存在问题导致，以往在XP时就出现过四核变双核的情况。解决办法可...
问题：进程有哪几部分组成,简述进程和程序的主要别
回答：...程序在没有被调用之前只能叫程序,被调用并得到了后就可以称其为进程了,进程可以由多线程组成,线程与进程的主要别在于同一进程里的线程之间可以共享一些临界,而进程之间则不可以,每个进程是孤立的,其实,无论是进程还是线程都是一段受命并在内存中得到执行的码.
问题：开机自检为两个CPU
回答：...型号可能是Pentium42.4CCPU。Pentium42.4CPU有3种型号，其中Pentium42.4C为200外频、12倍频、800FSB，具有超线程技术。当这样的CPU到支持超线程技术的升技IS7-E2上，自检时会显示两个CPU。而且BIOS中并没有将CPU外频设为正确的200，而是100，所以会显示2个1.2G的CPU。如果是这种情况，只要在开机时进入BIOS，将CPU外频设为200即可。
问题：“工学交替”实汇报
回答：“工学交替”实汇报 尊敬的院：您们好！我院08级机电一体化专业1—4班共174名学生于202月24日来到富士康科技进行为期四个月的“工学交替”实。至204月底已两个月。这两个月中，在我院的关怀下，系的大力支持下，通过系部教门、招生就业部门、专业教研室和驻辅导的共同努力，目前秩序井然，现就近期汇报如下...
问题：3dmax用vray渲染，原来4核电脑渲染时8块一起出图
回答：那是因为原来的4核（应该是INTEL 的CORE I7四核， 或者同期的至强CPU）支持超线程（即每个核心由软件模拟为两个核心同时运行）， 所以是8个线程同时渲染；而现在还的8核心（应该是AMD FX8150之类的推土机系列）但是不支持超线程， 所以还是8个线程渲染；这是由CPU本身的性能决定的， 无法调节。
问题：给电脑默认的IE工具提速
回答：我们都知道，像“网络蚂蚁”之类的工具速度都很快，因为它们都 是多线程的，也就是把一个分成若干份同时进行，而IE下 载速度之所以这么慢，是因为它用的是单线程，那我们能不能也给IE下 载加上多线程呢？可以通过修改表的方面来实现IE的多线程， 打开表，展开“HKEY_CURRENT_USER\Software\ Microsoft\Windows\Current-Version\Inter Settings...
问题：CPU故障的分析与：开机自检为两个CPU
回答：...能是Pentium 4 2.4C CPU。Pentium 4 2.4 CPU 有3种型号，其中Pentium 4 2.4C为200外频、12倍频、800FSB，具有超线程技术。当这样的CPU到支持超线程技术的升技IS7-E2上，自检时会显示两个CPU。而且BIOS中并没有将CPU外频设为正确的200，而是100，所以会显示2个1.2G的CPU。如果是这种情况，只要在开机时进入BIOS，将CPU外频设为200即可。
问题：佳能全系列打印机及清零方法
回答：...欧洲BJ模式4释放RESUME键清洁EEPROM。5将电源线从打印机上拔下来，再重新上去。ROM错 /绿灯交替闪 响1声RAM错 /绿灯交替闪 响2声BJ墨盒移位错 /绿灯交替闪 响3声原位错 /绿灯交替闪 响4声废墨满错 /绿灯交替闪 响5声度传感器错 /绿灯交替闪 响6声打印机位置校正错 /绿灯交替闪 响7声头度错 /绿灯交替闪 响8声头度传感器错 /绿灯交替闪 响9声清洁错 /绿...
问题：用漏洞提升计算机控制权限
回答：...修复工具，Webfldrs.msi组件在卸载的时候由于权限的问题而出错，从而出一个提示窗口。这时线程被挂起，新线程创建初期会创建一个堆对象，而正好这个对象可以被写入，者正是利用这个写入的机会将已经准备好的ShellCode写入到这个对象中，从而执行自己的ShellCode。提示:ShellCode是一组可以完成我们想要的功能的机器码，这些码通常都是以十六进制的数组形式存在的
问题：教你如何使用好超线程CPU
回答：超线程技术让INTEL处理器性能提升非常之大，给我们带累了更高的效率，但要用好超线程技术，也不是那么简单，起码要一些前提和一些技巧，这样才能打开超线程功能。一、如何打开超线程技术？要实现超线程技术需要具备三个条件，首先处理器需要支持该功能（如P42.8C等）；其次主板也要支持（如INTEL 865PE/875P等）；三是作系统也要支持（Windows2000/Windows XP支持，Windows...
问题：网络笔试试题
回答：...的英文缩写是什么?2、传统文本都是线性的、顺序的，而超文本则是?3、一个进程可以包含多个线程，什么线程分配给进程的主存空间。4、为了保证CPU执行程序指令时能正确访问存储单元，需要将程序中的逻辑转换为运行时可由机器直接寻址的物理，这一过程称为什么?5、系统为了管理，设置了控制块FCB。FCB是在执行什么系统调用时建立的。6...
问题：java中 由main()产生的线程是主线程， 我想可不可以一个线程后 结束掉主线程，让后建的线程成为主线程 行么？ 怎么做？回答：一个线程后，启动该线程．可以是多个．而此时的Main()函数就是主线程,其他线程与他同时进行．Main()里的语句执行完毕后就自然结束了(即主线程结束)．无须做过多处理．... 问题：进程有哪几部分组成,简述进程和程序的主要别
回答：...程序在没有被调用之前只能叫程序,被调用并得到了后就可以称其为进程了,进程可以由多线程组成,线程与进程的主要别在于同一进程里的线程之间可以共享一些临界,而进程之间则不可以,每个进程是孤立的,其实,无论是进程还是线程都是一段受命并在内存中得到执行的码.
11-0401-0711-3001-0101-0101-0101-0101-0107-1207-12}