线程是什么?

thread[英][θred] [美][θru025bd] 生词本简明释义n.线；线索；线状物；螺纹vt.穿成串；将（针、线等）穿过…；用…线缝；给…装入（胶片、狭带、绳子）复数：threads易混淆的单词：THREAD以下结果由 金山词霸 提供柯林斯高阶英汉词典 百科释义 短语词组 同反义词1.N-VAR（尤指用于缝纫的）细线，细丝Thread or a thread is a long very thin piece of a material such as cotton, nylon, or silk, especially one that is used in sewing.This time I"ll do it properly with a needle and thread.这次，我要用针线将它缝好。...a tiny Nepalese hat embroidered with golden threads.带有金丝线刺绣的尼泊尔小帽

thread的读音是：英[θred]。thread的读音是：英[θred]。thread的例句是Howmanyspoolsofthreaddidyouuse?你用了几轴线。thread名词:threader；过去式:threaded；过去分词:threaded；现在分词:threading；第三人称单数:threads。一、详尽释义点此查看thread的详细内容n.(名词)线思路，条理螺纹线状物线索衣服贯穿着的东西【计】线程细丝，细线纤维头绪一线，一丝麻纱，棉纱细流细矿脉情节v.(动词)穿，穿过，穿透过刻螺纹于使交织通，通过装软片于把...穿成一串，穿成串，串在一起穿线，拿线穿，穿线于?为照相机装胶片，装胶卷于挤过穿（针），纫（针）穿行滴下成丝状将穿过?将（影片）装入放映机给?装入（胶片、狭带、绳子）用?线缝，把?线编织进小心地通过蜿蜒前进二、英英释义Noun:afinecordoftwistedfibers(ofcottonorsilkorwoolornylonetc.)usedinsewingandweavinganylongobjectresemblingathinline;"amereribbonofland""thelightedribbonoftraffic""fromtheairtheroadwasagreythread""athreadofsmokeclimbedupward"theconnectionsthatlinkthevariouspartsofaneventorargumenttogether;"Icouldn"tfollowhistrainofthought""helostthethreadofhisargument"theraisedhelicalribgoingaroundascrewVerb:tomoveorcausetomoveinasinuous,spiral,orcircularcourse;"theriverwindsthroughthehills""thepathmeandersthroughthevineyards""sometimes,thegoutwandersthroughtheentirebody"passathreadthrough;"threadaneedle"removefacialhairbytyingafinestringarounditandpullingatthestring;"Shehadhereyebrowsthreaded"passthroughorinto;"threadtape""threadfilm"threadonorasifonastring;"stringpearlsonastring""thechilddrewglassbeadsonastring""threaddriedcranberries"三、网络解释1.1.螺纹：[摘要]旋装柴油滤清器(OILSPIN-ONFILTER)螺纹(THREAD)1.5×16UNF密封圈(...机油滤芯发布单位:德...四、例句Howmanyspoolsofthreaddidyouuse?你用了几轴线?Thethreadseemstomatchthecloth.这线和这布似乎很相称。Ineedonemorespoolofthreadbeforefinishingtheembroidery.再来一轴线我就可以完成这幅刺绣了。Hepassedmeacoilofthread.他递给我一卷线。Thegirltiedtheendsofthethread.这女孩把线的两端结起来。Thelittlegirlthreadedtheshellstogetherandworethemroundherneck.小女孩把贝壳穿成一串，戴在脖子上。I"mafraidI"velostthethreadofyourargument.我恐怕没有抓住你的论据的思路。五、常见句型用作名词(n.)Thethreadisformedintoaball.线结成球形。Fastenthethreadoffwithaknot.把线打个结系牢。Letmetakethatpieceofthreadoffyourskirt.让我把你裙子上的线头扯掉。Ineedsomeredthreadtosewthisdress.我需要一些红线缝制这件连衣裙。Yousewwiththread.用线缝纫。Tosewabuttonon,youneedaneedleandthread.缝纽扣需要针和线。Thespiderhungbyathread.蜘蛛悬在一根丝上。Therearethreadsofwoolonyourdress.你的衣服上有几根毛。Athreadoflightcamethroughthecrackinthedoor.一道光线从门缝中透进来。Athreadofwhitesmokeclimbedupthesky.一缕白烟袅袅升上天空。Athreadofpoetrymarkedallhiswriting.他所有的作品都带有一丝诗意。Thereisaconsistentthreadrunningthroughallthesepolicies.所有这些政策中贯穿着一条始终如一的主线。Ireturntoathreadofmystory.中断之后我又接着把故事讲下去。Iwentshoppingandgotsomethreads.我上街买了些衣服。用作动词(v.)用作及物动词S+～+n./pron.Thechildthreadedthebeads.这孩子用线把珠子串起来。Wethreadedtheforest.我们穿过森林。用作双宾动词S+～+pron./n.+n./pron.Pleasethreadmeaneedle.请给我穿根针。S+～+n./pron.+forpron./n.ShallIthreadtheneedleforyou?要我给你穿针吗?六、常用短语用作名词(n.)hangbya(single)thread千钧一发,岌岌可危(ofaperson"slife,etc.)dependonsthsmalllosethethread(of)失去(议论故事等的)头绪beunabletofollowanargument,story,etc.pick〔take〕upthethreads(谈话等中断后)继续讲下去;(关系等中断后)继续下去resumeone"slineofreasoning/wayoflifeafterabreakworntothe/athread破烂不堪的inragsortatters用作动词(v.)threadinto(v.+prep.)把?穿〔装,插〕入?passsthintotherequiredpositionforuse;insertsthintosththreadsthintosthThelittlegirlhelpedhergrandmothertothreadthewoolintotheneedle.小姑娘帮助奶奶把毛线穿到针上。Shethreadedthefilmintoaprojector.她把电影胶片装入放映机。Hethreadedseveralcausalideasintoacharmingessay.他把几段有关因果的概念穿插在一篇引人入胜的文章中。threadon(v.+prep.)把?穿在?上pass(sthsuchasathread)ontherequiredpositionforusethreadsthonsthHowdoyouthreadaneedleonthissewingmachine?你怎么把针穿在这台缝纫机上?Shewasthreadingpearlsonastringtomakeanecklace.她正在把珍珠穿成一串项链。threadthrough(v.+prep.)小心翼翼地穿过?;妥善处理?findawaytopasscarefullythrough(sthsuchasacrowd)ordealsatisfactorilywith(sthsuchasadifficulty)threadthroughsthThewirethreadedthroughsmallloops.金属丝穿过许多小环。threadsththroughsthThiswoolistoothickformetothreaditthroughtheeyeofthisfineneedle.对我来说,这毛线太粗了,我没法把它穿过这么小的针眼。threadthroughsthTheyhadtothreadthroughthenarrowpassages.他们不得不穿过狭窄的通道。Wewereabletothreadbutslowlythroughtheintricatereports.我们弄懂了这些复杂的报告,只是很慢。threadone"swaythroughsthThreadingmywaythroughthecrowd,Isoonreachedthefront.我小心翼翼地穿过人群,很快到了前面。Wegottherequickerbythreadingourwaythroughthebackstreets.穿过偏僻的街道,我们能够快些到达那儿。Ishouldbeabletothreadmywaythroughthedifficultiesfacingmeinmynewjob.我能克服在新工作中面临的困难。Mr.Whitethreadedhiswaythroughthelegalentanglements.怀特先生成功地解决了这些法律纠纷。七、词语用法n.(名词)thread用作名词的基本意思是“线”,可指用棉、毛、尼龙等制成的“线”,也可指细如线状的东西(如一丝亮光等),此时常用于athreadof结构。thread用于比喻还可作“(贯穿故事等各部分的)线索”或“(某人的)思路”解,此时常与lose,pick〔take〕up等连用。thread还可作“螺纹”“衣物,衣服”解,作“衣物,衣服”解时多见于美国俚语中,且常用于复数形式。v.(动词)thread的基本意思是将一根线穿进针眼中,指在比较狭窄或拥挤的地方穿梭(如在人群中挤过去),即“穿线,穿过”,常与介词into,on,through等连用。thread一般用作及物动词,接名词或代词作宾语,偶尔也可接双宾语,其间接宾语可以转化为介词for的宾语。thread泛指统指为“线”，而thread指“一根线”，复数形式threads指“多根线”。thread的相关近义词cotton、course、direction、drift、film、line、string、storyline、theme、ease、inch、meander、pass、string、weave、windthread的相关临近词threadbare、thrash、thready、threaded、threader、threading、threadfin、threadeye、threadout、Threadgill、threadfish、threadfit点此查看更多关于thread的详细信息

Java当中实现多线程的方法主要有两种方式：集成Thread类和实现Runnable接口定义线程的运行时行为，本文简单介绍一下Thread的简单使用 （1） 定义 Thread：Java中实现线程的具体类，封装了所有的线程操作，通过Thread实例来控制线程行为(运行，停止) （2）作用 实现多线程 （3）优点 实现简单 ，只需要继承Thread类并重写run()方法即可 （4）缺点 局限性大 :由于集成了Thread类，而Java为单继承方式，意味着当前线程不能再继承其他的类。 无法共享资源 :由于创建一个线程就常见了一个线程实例，而线程实例之间的数据无法进行共享。 资源消耗大 ：线程为相当于“一次性消耗品”,当运行完后就需要进行销毁，有当有多个耗时任务时就需要对应开启多个线程进行处理，且开启销毁多个线程本身就会消耗大量资源。 Thread主要有两种使用方法:(1)标准方式(2)匿名方式 (1)标准方式 (2)匿名方式 两种方法的对比 这也就是说如果有多个地方用到了线程类则选择标准方式，如果该线程只在一处使用则可以考虑匿名方式。 模仿售票，一共有两个服务窗口，每一秒售出一张票，每个窗口有100张票。 activity_main.xml: MainActivity.java: 测试结果 从测试结果可以看出两个线程的资源并没有共享，这是由于各个线程相对独立(不是同一个线程实例)。 以上就是Thead类实现多线程的全部内容。

线程（英文：thread），台湾地区译为执行绪（英文：thread ofexecution）、绪程，操作系统技术中的术语，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是行程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并行多个线程，每条线程并行执行不同的任务。在Unix SystemV及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。计算机科学术语，指运行中的程序的调度单位。线程具有以下属性。　　1）轻型实体　　线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源，比如，在每个线程中都应具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。　　2）独立调度和分派的基本单位。　　在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小。　　3）可并发执行。　　在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行。　　4）共享进程资源。　　在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。

非常简单,string是绳子,弦,带子,thread是线,头绪,思路简单的说一个英式一个美式

在一个Android 程序开始运行的时候，会单独启动一个Process。默认的情况下，所有这个程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的两种，除此之外还有Content Provider和Broadcast Receiver）都会跑在这个Process。一个Android 程序默认情况下也只有一个Process，但一个Process下却可以有许多个Thread。在这么多Thread当中，有一个Thread，我们称之为UI Thread。UI Thread在Android程序运行的时候就被创建，是一个Process当中的主线程Main Thread，主要是负责控制UI界面的显示、更新和控件交互。在Android程序创建之初，一个Process呈现的是单线程模型，所有的任务都在一个线程中运行。因此，我们认为，UI Thread所执行的每一个函数，所花费的时间都应该是越短越好。而其他比较费时的工作（访问网络，下载数据，查询数据库等），都应该交由子线程去执行，以免阻塞主线程。那么，UI Thread如何和其他Thread一起工作呢？常用方法是：诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。例如，在子线程的状态发生变化时，我们需要更新UI。如果在子线程中直接更新UI,通常会抛出下面的异常：11-07 13:33:04.393: ERROR/JavaBinder(1029):android.view.ViewRoot$CalledFromWrongThreadException:Only the original thread that created a view hierarchy can touch its views.意思是，无法在子线程中更新UI。为此，我们需要通过Handler物件，通知主线程Ui Thread来更新界面。

最近整理的jdk1.8最新方法，详细具体用法下载个1.8手册看看就可以Thread()、Thread(Runnable target)、Thread(Runnable target, String name)、Thread(String name)、Thread(ThreadGroup group, Runnable target)、Thread(ThreadGroup group, Runnable target, String name)、Thread(ThreadGroup group, Runnable target, String name, long stackSize)、Thread(ThreadGroup group, String name)、static int activeCount()、void checkAccess()、static、Thread currentThread()、static void dumpStack()、static int enumerate(Thread[] tarray)、static Map<Thread,StackTraceElement[]> getAllStackTraces()、ClassLoader getContextClassLoader()、static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()、long getId()、String getName()、int getPriority()、StackTraceElement[] getStackTrace()、Thread.State、getState()、ThreadGroup getThreadGroup()、Thread.UncaughtExceptionHandlergetUncaughtExceptionHandler()、void interrupt()、static boolean interrupted()、boolean isAlive()、boolean isDaemon()、boolean isInterrupted()、void join()、void join(long millis)、void join(long millis, int nanos)、void run()、void setContextClassLoader(ClassLoader cl)、void setDaemon(boolean on)、static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)、void setName(String name)、void setPriority(int newPriority)、void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)、static void sleep(long millis)、static void sleep(long millis, int nanos)、void start()、String toString()、static void yield()

runnable和thread的区别（多线程必须用Runable）Java中有两种实现多线程的方式以及两种方式之间的区别看到一个面试题.问两种实现多线程的方法.没事去网上找了找答案. 网上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了. Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？ 为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。 首先这样编写这个程序： Java代码 class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket > 0){System.out.println(Thread.currentThread().getName() +"is saling ticket" + ticket--);}else{break;}}} } 源码打印？class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket > 0){System.out.println(Thread.currentThread().getName() +"is saling ticket" + ticket--);}else{break;}}} } main测试类: Java代码 public class ThreadDome1{public static void main(String[] args){ThreadTest t = new ThreadTest();t.start();t.start();t.start();t.start();} } 源码打印？public class ThreadDome1{public static void main(String[] args){ThreadTest t = new ThreadTest();t.start();t.start();t.start();t.start();} } 上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。 我们接着修改ThreadDemo1，在main方法中创建四个Thread对象： Java代码 public class ThreadDemo1{public static void main(String[] args){new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();} } 源码打印？public class ThreadDemo1{public static void main(String[] args){new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();} } Java代码 class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket > 0){System.out.println(Thread.currentThread().getName() +" is saling ticket" + ticket--);}else{break;}}} } 源码打印？class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket > 0){System.out.println(Thread.currentThread().getName() +" is saling ticket" + ticket--);}else{break;}}} } 这下达到目的了吗？ 从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。 经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。 Java代码 public class ThreadDemo1{public static void main(String[] args){ThreadTest t = new ThreadTest();new Thread(t).start();new Thread(t).start();new Thread(t).start();new Thread(t).start();} } 源码打印？public class ThreadDemo1{public static void main(String[] args){ThreadTest t = new ThreadTest();new Thread(t).start();new Thread(t).start();new Thread(t).start();new Thread(t).start();} } Java代码 class ThreadTest implements Runnable{private int tickets = 100;public void run(){while(true){if(tickets > 0){System.out.println(Thread.currentThread().getName() +" is saling ticket " + tickets--);}}} } 源码打印？class ThreadTest implements Runnable{private int tickets = 100;public void run(){while(true){if(tickets > 0){System.out.println(Thread.currentThread().getName() +" is saling ticket " + tickets--);}}} } 上面的程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。 可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处： (1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。 (2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。 (3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

1） start：用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。2） run：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。

线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。在多中央处理器的系统里，不同线程可以同时在不同的中央处理器上运行，甚至当它们属于同一个进程时也是如此。大多数支持多处理器的操作系统都提供编程接口来让进程可以控制自己的线程与各处理器之间的关联度（affinity）。有时候，线程也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。进程可以支持多个线程，它们看似同时执行，但互相之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，但您必须小心，确保它们不会妨碍同一进程里的其它线程。Java 线程工具和 API 看似简单。但是，编写有效使用线程的复杂程序并不十分容易。因为有多个线程共存在相同的内存空间中并共享相同的变量，所以您必须小心，确保您的线程不会互相干扰。

thread是线程，是操作系统能够进行运算调度的最小单元。string是字符串，是一种数据类型。

一般来说，我们把正在计算机中执行的程序叫做“进程”(process），而不将其称为“程序”(program）。所谓“线程”(Thread），是“进程”中某个单一顺序的控制流。新兴的操作系统，如Mac、Windows 9x、Windows NT等，大多采用多线程的概念，把线程视为基本执行单位。线程也是C++11标准 、Java语言、Python语言中的相当重要的组成部分之一。甚至最简单的Applet也是由多个线程来完成的。在Java中，任何一个Applet的paint()和update()方法都是由AWT(Abstract Window Toolkit）绘图与事件处理线程调用的，而Applet 主要的里程碑方法——init(),start(),stop()和destory() ——是由执行该Applet的应用调用的。单线程的概念没有什么新的地方，真正有趣的是在一个程序中同时使用多个线程来完成不同的任务。某些地方用轻量进程（lightweight process）来代替线程，线程与真正进程的相似性在于它们都是单一顺序控制流。然而线程被认为轻量是由于它运行于整个程序的上下文内，能使用整个程序共有的资源和程序环境。作为单一顺序控制流，在运行的程序内线程必须拥有一些资源作为必要的开销。例如，必须有执行堆栈和程序计数器。在线程内执行的代码只在它的上下文中起作用，因此某些地方用“执行上下文”来代替“线程”。

启动一个线程

Thread协议栈是可靠，经济高效，低功耗，无线D2D（设备到设备）通信的开放标准。它是专为连接家庭应用而设计的，其中需要基于IP的网络，并且可以在协议栈中使用各种应用层。 这些是Thread协议栈和网络的一般特性： 图1显示了Thread协议栈的概述。 该标准基于在2.4GHz频带中以250kbps运行的IEEE 802.15.4 [IEEE802154] PHY（物理层）和MAC（媒体访问控制层）。该规范的IEEE 802.15.4-2006版本用于Thread协议栈。 802.15.4 MAC层用于基本的消息处理和拥塞控制。该MAC层包括设备用于监听干净信道的CSMA（Carrier Sense Multiple Access，载波侦听多路访问）机制，以及用于处理重试和确认消息的链路层以用于相邻设备之间的可靠通信。基于由软件协议栈的较高层建立和配置的密钥，被MAC层用于对消息的加密和完整性保护。网络层建立在这些基础机制上，以在网络中提供可靠的端对端通信。 在由运行Thread协议栈的设备组成的系统中，这些设备都不代表单点故障。虽然系统中有许多设备执行特殊功能，但是Thread协议栈的设计使得它们可以被替换，而不会影响Thread网络中正在进行的通信。例如，一个常眠的子设备需要一个父设备进行通信，因此这个父设备代表它的通信失败单点。但是，如果常眠设备的父设备不可用，常眠设备可以并将会选择另一个父设备，因此该转换不应该对用户可见。 虽然系统设计用于没有单点故障，但在某些拓扑结构下，将存在没有备份功能的单个设备。例如，在具有单个网关的系统中，如果网关断电，则无法切换到另一个网关。 路由器或边界路由器可以为Thread网络中的某些功能承担Leader角色。这个Leader需要在网络内作出决定。例如，Leader分配路由器地址并允许新的路由器请求。Leader角色是被选举的，如果Leader失败，会由另一个路由器或边界路由器承担Leader角色。正是这种自主操作确保没有单点故障。 边界路由器是一种特定类型的路由器，提供从802.15.4网络到其他物理层（例如，Wi-Fi和以太网）上的相邻网络的连接。边界路由器为802.15.4网络中的设备提供服务，包括用于离网操作（off-network operations）的路由服务。Thread网络中可能有一个或多个边界路由器。 路由器为网络设备提供路由服务。路由器还为尝试加入网络的设备提供加入和安全服务。路由器是设计为不休眠的。路由器可以降级其功能并成为REED（Router-eligible End Devices，符合路由器的终端设备）。 REED有能力成为路由器，但是由于网络拓扑或条件，这些设备不作为路由器工作。这些设备通常不转发消息或为Thread网络中的其他设备提供加入或安全服务。如果需要，Thread网络管理REED成为路由器，且无需用户交互。 常眠终端设备是主机设备。他们只通过他们的父路由器进行通信，不能转发其他设备的消息。 Thread协议栈中的设备支持[RFC 4291]中指定的IPv6寻址架构。设备配置1个或多个ULA（Unique Local Address，唯一本地地址）或GUA（Global Unicast Address，全局单播地址）地址。 启动网络的设备选择一个/64前缀，然后在整个Thread网络中使用。该前缀是本地分配的全局ID（Locally Assigned Global ID），通常称为ULA前缀[RFC 4193]，可以称为网格本地ULA前缀（mesh local ULA prefix）。Thread网络还可以具有一个或多个边界路由器，每个边界路由器可以具有或可以不具有可以用于生成附加GUA的前缀。Thread网络中的设备使用其扩展MAC地址（Extended MAC address）来导出其[RFC 4944]第6节中定义的接口标识符（interface identifier），并且基于此，通过已知的本地前缀FE80 :: 0/64配置链路本地IPv6地址，如[RFC 4862]和[RFC 4944]所述。 设备还支持适当的多播地址（multicast addresses）。这包括链路本地所有节点组播（link-local all node multicast），链路本地全路由器组播（link-local all-router multicast）和区域本地组播（realm-local multicast）。 加入Thread网络的每个设备都将分配一个16位短地址，如[IEEE 802.15.4]中所规定。对于路由器，该地址使用地址字段中的较高位分配，低位设置为0，表示路由器地址。然后，对于子设备使用其父设备的高位和适当的低位来为其地址分配一个16位的短地址。这允许Thread网络中的任何其他设备通过使用其地址字段的高位来了解子设备的路由位置。 图2说明了Thread短地址。 所有设备使用[RFC 4944]和[RFC 6282]中定义的6LoWPAN。 在Thread网络中使用头部压缩（Header compression），设备传输消息尽可能多地压缩IPv6报头，以最小化发送的数据包的大小。 支持网格包头（mesh header），用于更有效地压缩网格内的消息，以及针对如“路由和网络连接”部分中所述的链路层转发（link layer forwarding）。网格标头（mesh header）还允许消息的端到端分段（end-to-end fragmentation），而不是[RFC 4944]中指定的逐跳分段（hop by hop fragmentation）。Thread协议栈使用路由选择配置（route-over configuration）。 这些设备不支持[RFC 6775]中规定的邻居发现（neighbor discovery），因为DHCPv6用于向路由器分配地址。终端设备和REED由他们的路由器父节点分配短地址。然后，该短地址用于配置用于网络内通信的网格（Mesh）本地ULA。 有关6LoWPAN使用和配置的更多详细信息，请参见“6LoWPAN的Thread用法（Thread Usage of 6LoWPAN）”白皮书。Thread规范的第3章详细说明了使用的具体6LoWPAN配置。 设备支持ICMPv6（Internet Control Message Protocol version 6，Internet控制消息协议版本6）协议[RFC 4443]和ICMPv6错误消息，以及回显请求（echo request）和回显回复消息（echo reply messages）。 Thread协议栈支持在[RFC 768]中定义的UDP（用户数据报协议），用于设备之间的消息传递。 Thread协议栈支持Thread网络中所有路由器之间的全网格连接（full mesh connectivity）。 实际拓扑基于Thread网络中路由器的数量。如果只有一个路由器或边界路由器，则形成具有单个路由器的基本星形拓扑。如果有多个路由器，则自动形成网格（Mesh）拓扑。图3说明了Thread网络的基本拓扑结构和设备类型。 网格网络（Mesh Networks）通过允许射频转发其他射频的消息，使射频系统更可靠。例如，如果节点不能直接向另一个节点发送消息，则网格网络（Mesh Networks）通过一个或多个中间节点转发消息。如“路由和网络连接”一节中所讨论的，Thread网络的性质使得所有路由器节点彼此之间保持路由和连接，因此网格不断维护和连接。Thread网络中通常有最多32个活动路由器的限制。但是，64个路由器地址用于允许回收路由器地址。 在网格网络（Mesh Networks）中，常眠终端设备或REED不会为其他设备路由。这些设备将消息发送到作为路由器的父设备。该父路由器处理其子设备的路由操作。 Thread网络通常最多有32个活动路由器，它们使用基于设备路由表的消息的下一跳路由（next-hop routing）。设备路由表由协议栈维护，以确保所有路由器都具有Thread网络中任何其他路由器的连接和最新路径。使用RIP（Routing Information Protocol，路由信息协议）算法（来自[RFC 1058]和[RFC 2080]的算法，但不采用其特定的消息格式）。所有路由器与其他路由器使用MLE（Mesh Link Establishment），以压缩格式交换其到Thread网络中的其他路由器的路由成本（cost of routing）。 注意：从IP的角度来看，Thread网络支持路由器和主机。主机是常眠终端设备或REED。 MLE消息（请参阅“Thread规范”第4章“消息链路建立（Message Link Establishment）” 中针对Thread进行的扩展[draft-kelsey-intarea-mesh-link-establishment-06]) 用于建立和配置安全射频链路，检测邻近设备，以及维护Thread网络中设备之间的路由成本。使用单跳链路本地单播（single-hop link local unicasts）和路由器之间多播（multicasts between Routers）来传输MLE消息。 随着拓扑和物理环境的变化，MLE消息用于识别，配置和保护邻近设备的链路。MLE还用于分发跨Thread网络共享的配置值，如通道（channel）和PAN（Personal Area Network，个人区域网络）ID。这些消息可以由MPL（Multicast Protocol for Low power and Lossy Networks，低功耗和有损网络的多播协议）指定的简单洪泛转发（forwarded with simple flooding）。（有关详细信息，请参阅[draft-ietf-roll-trickle-mcast-09]）。 在建立两个设备之间的路由成本时，MLE消息还确保考虑了非对称链路成本（asymmetric link costs）。802.15.4网络中的非对称链路成本（asymmetric link costs）很常见。为了确保双向通信是可靠的，考虑双向链路的成本是很重要的。 按需路由发现（On-demand route discovery）通常用于低功耗802.15.4网络。然而，由于路由发现请求洪泛网络（route discovery requests flooding the network），按需路由发现（on-demand route discovery）在网络开销和带宽方面是昂贵的。 在Thread网络中，所有路由器定期交换包含到所有邻居路由器链路成本信息（link cost information to all neighbor Routers）的单跳MLE广告包（single-hop MLE advertisement packets），以及到Thread网络中所有其他路由器的路径开销（path costs to all other Routers）。通过这些定期的本地更新，所有路由器都具有Thread网络中任何其他路由器的最新路径开销信息，因此不需要按需路由发现。如果路由不再可用，路由器可以在到达目的地的下一个最合适的路由上进行选择。这种自愈路由机制允许路由器快速检测其他路由器是否已经脱离Thread网络，并计算最佳路径以维护与Thread网络中所有其他设备的连接。 每个方向的链路质量（link quality in each direction）基于来自该邻近设备的传入消息的链路成本（link cost on incoming messages from that neighboring device）。此传入链路成本（incoming link cost）映射到从0到3的链路质量（link quality）。值为0表示未知成本。链路成本（link cost is a measure of RSSI）是接收到的消息高于接收等级的RSSI（接收信号强度指示）的度量。 表1总结了链路质量和链路成本。 图4示出了Thread网络上的各种链路成本的示例。 Thread网络中任何其他节点的路径开销就是到达该节点的链路成本的最小值。路由器监控这些成本，即使网络的射频链路质量或拓扑变化，并通过使用周期性MLE广告消息在Thread网络传播新的成本。路由成本基于两个设备之间的双向链路质量。 为了说明一个简化的例子，想象一下预先委托的网络（pre-commissioned network），其中共享安全材料，所有的设备同时启动。每个路由器将周期性地发送初始填充的到单跳邻居成本的广告。在内部，每个路由器将存储未在广告中发送的下一跳信息（next hop information）。 前几个广告的路径成本等于链路成本，因为已知的唯一路由器是立即邻居，如图5所示。 但是，随着路由器开始收听来自邻居的广告，其中包含两跳或更多跳的其他路由器的成本，它们的表填充了多跳路径成本，然后传播得更远，直到最终在所有路由器之间存在如图6和图7所示的连接信息网络。 当路由器从邻居接收到新的MLE广告时，它或者已经具有该设备的邻居表项，或者添加一个。MLE广告包含来自邻居的进入成本（incoming cost from the neighbor），因此在路由器的邻居表中更新（updated in the Router"s neighbor table）。MLE广告还包含其他路由器的更新的路由信息u200bu200b（updated routing information for other Routers），并且该信息在设备路由表中更新（updated in the device routing table）。 通过查看子设备的地址的高位来确定父路由器地址（Parent Router address），可以实现到子设备的路由。一旦设备知道父路由器，它就具有该设备的路径开销信息和下一跳路由信息（path cost information and next-hop routing information）。 活动路由器的数量仅限于可以包含在单个802.15.4数据包中的路由和成本信息的数量。此限制目前为32个路由器，但提供了64个活动路由器地址以允许老化掉路由器地址（aging out of Router addresses）。 设备使用IP路由转发数据包（IP routing to forward packets）。设备路由表（device routing table）填充有路由器的网格本地ULA地址的压缩形式和适当的下一跳（compressed form of a mesh local ULA address for Routers and the appropriate next hop）。 距离向量路由（Distance vector routing）用于获取到Thread网络上路由器地址的路由（get routes to Router addresses）。当在Thread网络上进行路由时，该16位地址的高6位定义了目标路由器的路由器地址。如果目的地址的低位为0，则路由器为最终目的地址。否则，目的路由器负责根据16位目的地址的较低位转发到最终目的地。 对于超出Thread网络的路由，边界路由器通知Leader其所服务的特定前缀（particular prefix(es) it serves），并且该信息作为MLE数据包中的Thread网络数据分发（distributed as Thread Network data within the MLE packets）。Thread网络数据包括：前缀数据（prefix data），它是前缀本身，6LoWPAN上下文（6LoWPAN context），边界路由器（Border Routers）和该前缀的DHCPv6服务器（DHCPv6 server for that prefix）。如果设备要使用该前缀配置IPv6地址，则使用SLAAC（Stateless Address Autoconfiguration，无状态地址自动配置）或联系相应的DHCP（Dynamic Host Configuration Protocol，动态主机配置协议）服务器。Thread网络数据还包括路由服务器列表（a list of routing servers），它们是默认的边界路由器的路由器地址。 Leader被指定做出决策，选择REED成为路由器或允许路由器降级为REED。Leader也分配和管理路由器地址。然而，此路由Leader中包含的所有信息都存在于其他路由器中，并且如果路由Leader变得无法访问，则另一个路由器将自主被选择并作为Leader接管，而无需用户干预。 虽然在Thread协议栈中使用UDP消息传递，但仍然需要可靠的消息传递。这是使用一系列轻量级机制完成的，如下所示： 加入设备（joining device）必须经历各个阶段才能参与Thread网络： 所有加入都是Thread网络中用户启动的。一旦加入，设备就可以完全参与Thread网络，并可以与Thread网络内外的其他设备和服务交换应用层信息。 加入设备（joining device）必须发现Thread网络，并与路由器建立联系（establish contact with a Router）以进行调试（commissioning）。加入设备扫描所有信道（scans all channels），在每个信道上发出信标请求（issues a beacon request），并等待信标响应（waits for beacon responses）。信标包含一个有效载荷，包括网络SSID（Service Set Identifier，服务集标识符）和允许加入信标的许可证（a permit joining beacon），指示Thread网络是否正在接受新的成员。一旦设备发现Thread网络，它将使用MLE消息来建立一个相邻的路由器（establish a neighboring Router），通过它可以执行调试（perform commissioning）。 如果设备已经获得了调试信息（obtained commissioning information），因为它已经有足够的信息直接附加到Thread网络，则不需要发现。 Thread提供两种调试方法： 注意：仅在通过信标有效载荷中的许可证加入标志（joining solely via the permit joining flag in the beacon payload）的典型802.15.4加入方法不在Thread网络中使用。这种方法最常用于没有用户界面或到设备的带外频道的按钮类型加入（push button type joining）。在有多个网络可用的情况下，该方法可能存在设备转向（device steering）问题，并且也可能存在安全问题。 具有调试信息（commissioning information）的加入设备（joining device）与父路由器联系，然后通过父路由器交换MLE链路配置消息（exchanging MLE link configuration messages）附加到Thread网络。设备作为终端设备（end device）或REED附加到Thread网络，并由父路由器分配16位短地址，如图8所示。 一旦REED已经附加到Thread网络，它可能会发出一个地址请求（issue an address request）成为一个路由器，然后由Leader分配一个路由器地址。 一旦设备连接到Thread网络，就需要有各种各样的信息来保持其在网络中的参与。MLE提供服务以在整个网络中分发网络数据，并在邻居之间交换链路成本（link costs）和安全帧计数器（security frame counters）。 MLE消息分发或交换以下信息： 注意 ：MLE消息是被加密的，除非是在发现时，加入设备获得所需的安全资料过程中。 DHCPv6 [RFC 3315]是一种基于UDP的客户端 - 服务器协议，用于管理网络中设备的配置。DHCPv6使用UDP从DHCP服务器请求数据。 边界路由器上的DHCPv6服务用于配置： 所有设备都支持ICMPv6错误消息，以及回显请求（ echo request）和回显回应消息（ echo reply messages）。 设备上的应用层可以访问一组设备管理和诊断信息，这些信息可以在本地使用或收集并发送到其他管理设备。 Thread协议栈从802.15.4 MAC层使用的信息包括： Thread协议栈从网络层使用的信息包括： 由于各种原因，在现场操作的设备可能会意外重置或故障重置。已重置的设备需要重新启动网络操作，无需用户干预。为此，需要将一组信息存储在非易失性存储中。这包括：

线程是操作系统中的基本执行单元，也被称为轻量级进程。线程是进程的一部分，一个进程可以包含多个线程，每个线程都有自己的执行路径和状态。与进程相比，线程更加轻量级，创建和销毁的开销更小，可以更快地切换上下文并且共享同一进程中的资源。线程有以下几个特点：1. 独立性：每个线程都有自己的执行路径和状态，它们之间互不干扰。2.共享性：多个线程可以共享同一进程中的资源（如内存、文件等），这使得程序设计更加灵活高效。3. 并发性：多个线程可以同时执行，从而提高了程序的并发度和响应速度。4. 轻量级：相比于进程而言，线程创建和销毁的开销更小，并且在切换上下文时也更加快速。5. 可以实现协作式多任务处理：通过使用锁、信号量等同步机制来协调不同线程之间的工作，在保证数据安全的同时提高了程序效率。

　　螺纹(THREAD)是什么，紧固件咨询顾问俞文龙认为螺纹(THREAD)是在圆柱或圆锥母体表面上制出的螺旋线形的、具有特定截面的连续凸起部分。螺纹按其母体形状分为圆柱螺纹和圆锥螺纹；按其在母体所处位置分为外螺纹、内螺纹，按其截面形状（牙型）分为三角形螺纹、矩形螺纹、梯形螺纹、锯齿形螺纹及其他特殊形状螺纹。紧固件咨询顾问俞文龙认为，最好自己查相关资料，网上得来总是假，碰到不懂装懂的，随便应答的，根本就是假的或骗人的就直接误导你，甚至害惨你。

是线程多线程概述 进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。 线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。 每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。 多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。这一点在多线程编程时应该注意。 Win32 SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。Visual C++ 6.0中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。三、Win32 API对多线程编程的支持 Win32 提供了一系列的API函数来完成线程的创建、挂起、恢复、终结以及通信等工作。下面将选取其中的一些重要函数进行说明。1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId); 该函数在其调用进程的进程空间里创建一个新的线程，并返回已建线程的句柄，其中各参数说明如下： lpThreadAttributes：指向一个 SECURITY_ATTRIBUTES 结构的指针，该结构决定了线程的安全属性，一般置为 NULL； dwStackSize：指定了线程的堆栈深度，一般都设置为0； lpStartAddress：表示新线程开始执行时代码所在函数的地址，即线程的起始地址。一般情况为(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是线程函数名； lpParameter：指定了线程执行时传送给线程的32位参数，即线程函数的参数； dwCreationFlags：控制线程创建的附加标志，可以取两种值。如果该参数为0，线程在被创建后就会立即开始执行；如果该参数为CREATE_SUSPENDED,则系统产生线程后，该线程处于挂起状态，并不马上执行，直至函数ResumeThread被调用； lpThreadId：该参数返回所创建线程的ID；如果创建成功则返回线程的句柄，否则返回NULL。2、DWORD SuspendThread(HANDLE hThread); 该函数用于挂起指定的线程，如果函数执行成功，则线程的执行被终止。3、DWORD ResumeThread(HANDLE hThread); 该函数用于结束线程的挂起状态，执行线程。4、VOID ExitThread(DWORD dwExitCode); 该函数用于线程终结自身的执行，主要在线程的执行函数中被调用。其中参数dwExitCode用来设置线程的退出码。5、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode); 一般情况下，线程运行结束之后，线程函数正常返回，但是应用程序可以调用TerminateThread强行终止某一线程的执行。各参数含义如下： hThread：将被终结的线程的句柄； dwExitCode：用于指定线程的退出码。 使用TerminateThread()终止某个线程的执行是不安全的，可能会引起系统不稳定；虽然该函数立即终止线程的执行，但并不释放线程所占用的资源。因此，一般不建议使用该函数。6、BOOL PostThreadMessage(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam); 该函数将一条消息放入到指定线程的消息队列中，并且不等到消息被该线程处理时便返回。 idThread：将接收消息的线程的ID； Msg：指定用来发送的消息； wParam：同消息有关的字参数； lParam：同消息有关的长参数； 调用该函数时，如果即将接收消息的线程没有创建消息循环，则该函数执行失败。

thread Please give me a piece of thread. 请给我一段线. She threaded the needle for her grandmother. 她为祖母穿针. round The doctor is on his round of visits. 医生在巡回出诊. The spacecraft rounded the moon. 宇宙飞船环绕月球飞行. narrow The river narrows at this point. 河面到了这儿变得很狭窄. Four people were canoeing on Breves Narrows on the Amazon River price Prices keep going up. 物价持续上涨. The watch was priced at $200. 这只手表标价二百美元. live He lived to the age of 70. 他活到七十岁.(无名词形式) tower That"s a television tower. 那是电视转播台. The tall building towers above all the others. 这高楼高出其他所有的建筑. dwarf There are some children who remain as dwarfs because they lack a particular hormone. 有些孩子一直长不高,因为他们身上缺少一种特殊的荷尔蒙. The new building dwarfs all the other buildings in the town. 新大楼使城里所有其他建筑物都显得矮小了.

返回当前的线程

这是的this表示当前类对象，也就是Threadthread=newThread(this),这段代码所处的类对象，想必当前类实现了Runnable接口，实现了Runnable接口的run方法，那Threadthread=newThread(this)表示创建一个线程对象(thread)，当调用thread.start()时则表示开启线程，准备执行线程中的run方法。

线索

是线程的意思线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。通过下图来区别单线程程序与多线程程序的不同：单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

CreateThread()函数用于创建线程；返回值为所创建线程的句柄。ExitThread()函数用于结束本线程。SuspendThread()函数用于挂起指定的线程。ResumeThread()函数递减指定线程的挂起计数，挂起计数为0时，线程恢复执行。 pthread_create()函数用于创建线程。返回值为创建线程失败时的错误码；若返回0，表示线程创建成功。 pthread_exit()函数用于结束当前线程。 pthread_join()函数用于等待线程运行结束。 UNIX International 线程thr_create()函数用于创建线程。 thr_join()函数用于等待线程运行结束。 thr_suspend()函数用于挂起线程。 thr_continue()函数用于恢复被挂起的线程。 thr_exit()函数用于结束当前线程。 thr_self()函数用于返回当前线程的线程标识符。 thrd_create()函数用于创建线程。 thrd_join()函数用于等待线程运行结束。 thrd_exit()函数用于结束当前线程。 thrd_current()函数用于返回当前线程的线程标识符。 thrd_sleep()函数用于让线程休眠指定时间。 std::thread::thread()，构造函数，用于创建线程。 std::thread::join()，用于等待线程运行结束。 std::thread::detach()，用于让线程不受句柄控制。 std::thread::swap()，用于交换两个线程。 std::thread::get_id()，用于获得线程ID号。 std::thread::joinable()，用于判断线程是否可等待。 std::thread::native_handle()，用于获得与操作系统相关的原生线程句柄。 start()，启动线程。join()，等待线程运行完毕。sleep()，让线程休眠一段时间。setPriority()，设置线程优先级。

你好，Task和Thread的区别：task是根据自己需要调用线程thread就是个基本单位简单地说，thread是单核多线程，task是多核多线程Task是将多个操作封装成一个概念上原子操作。但这个操作由哪个Thread甚至多个Thread来处理处理你并不清楚。总之就是可以被正常完成。Thread仅仅是一条线程，所有操作都是这个Thread一个人完成的。Task属于多核开发的封装。跟单线程工作的任务有很大的区别，甚至是本质上的区别。所以可比性不大。个人理解，不足之处还望大神指正

问题一：多线程工作是什么意思？ 什么是线程？ 英文：Thread 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的 *** ，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。 什么是多线程？ 多线程是为了使得多个线程并行的工作以完成多项任务，以提高系统的效率。线程是在同一时间需要完成多项任务的时候被实现的。 使用线程的好处有以下几点： u30fb使用线程可以把占据长时间的程序中的任务放到后台去处理 u30fb用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度 u30fb程序的运行速度可能加快 u30fb在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。 胆还有其他很多使用多线程的好处，这里就不一一说明了。 一些线程模型的背景 我们可以重点讨论一下在Win32环境中常用的一些模型。 u30fb单线程模型 在这种线程模型中，一个进程中只能有一个线程，剩下的进程必须等待当前的线程执行完。这种模型的缺点在于系统完成一个很小的任务都必须占用很长的时间。 问题二：什么是线程？？ 线程也被称为轻量进程计算机科学术语，指运行中的程序的调度单位。 线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。 在多中央处理器的系统里，不同线程可以同时在不同的中央处理器上运行，甚至当它们属于同一个进程时也是如此。大多数支持多处理器的操作系统都提供编程接口来让进程可以控制自己的线程与各处理器之间的关联度 问题三：线程是什么意思1-100线程的区别 就相当于一条路，有几条车道 问题四：四核八线程是什么意思？ 四核好理解 四个核心就是了 没鼎么可说的 八线程其实就是根据核心而来的 简单的理解就是这颗CPU支持超线程 每个核心超线程后会模拟成两个U 实际属性里就是这么显示 这样四个核心就是八个线程 四核是物理四核 八线程是虚拟的八线程 在03年左右那时候就开始有P4处理器支持超线程技术 一般电脑的奔腾4标志上会有个HT的字样 表示的就是超线程 在我的电脑属性里查看处理器属性就是两个处理器 实际上就是超线程技术后显示的结果 但是实际性能要比现在的物理双核差远了 问题五：什么是线程、什么又是多线程 它们之间有什么区别呢？ 说法一：进程是具有一定独立功能的程序关于某个数据 *** 上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行 说法二：进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。 说法三：多线程共存于应用程序中是现代操作系统中的基本特征和重要标志。用过UNIX操作系统的读者知道进程，在UNIX操作系统中，每个应用程序的执行都在操作系统内核中登记一个进程标志，操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配，但进程和线程有什么区别呢？ 进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于： 线程的划分尺度小于进程，使得多线程程序的并发性搞。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。 进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。 C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括： ●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间； ......>> 问题六：线程的中断是什么意思 线程的中断不是让线程停止 java中线程的中断(interrupt)只是改变了线程的中断状态,这个中断状态改变后带来的结果,是无法确定的, 有时它更是让停止中的线程继续执行的唯一手段.不但不是让线程停止运行,反而是继续执行线程的手段. 问题七：线程是什么意思 先看看专业的解释是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。 线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程. 线程和进程的区别在于,子进程和父进程有不同的代码和数据空间,而多个线程则共享数据空间,每个线程有自己的执行堆栈和程序计数器为其执行上下文.多线程主要是为了节约CPU时间,发挥利用,根据具体情况而定. 线程的运行中需要使用计算机的内存资源和CPU .....我用例子给你说下比如你们学校大扫除，分工到每一个班级你们班级就叫做进程，负责的任务是大扫除，就是主线程然后你们班有3个小组，第一组扫地，第二组拖地，第三组擦窗户那么这三组分别做了三种不同的事情，可以看作三个线程也就是说线程隶属于进程是一个包含被包含的关系每个线程的作用不一样就上上面我说的三个线程，一个作用是扫地，一个是拖地，一个擦窗户理解起来也不是很难 问题八：cpu的四线程是什么意思？ 双核心四线程，即拥有两个物理核心，然后再虚拟两个虚拟核心来工作，这是intel(英特尔)的技术，叫HT(超线程)技术。一个核心的性能不能充分发挥，因此，intel为了能让一个核心能充分发挥全部性能，让CPU核心可以同时执行多个线程，从而发挥CPU核心的更多性能。 四核四线程就是四个核心，四个线程，一个核心使用一个线程。 在使用来说，多任务的话肯定是四核四线程性能更为优秀，毕竟是真实的四核，而双核四线程再怎么高的性能也是只有两个核心在工作。 跟你打个比方，双核四线程可以比喻两个人在看书，但是为了充分发挥效率，让两个人一起做四件事，那么就是两个核心分别一边读书一边写字。而四核四线程你可以比喻两个人看书，两个人写字。一个是充分发挥效率，一个是各司其职，各做各的，但是怎么说也是多核心多线程性能更为优秀。 问题九：线程是什么 mysql线程什么意思 数据库有自己的连接锁机制，如果是针对同一台机器使用同一个接口进行插入的话多线程和单线程是一样的。除非你有好几台数据库服务器，这样再使用多线程来进行上面的工作的话效率才会明显提高。

分类: 教育/科学 >> 外语学习 问题描述: 如题！ 解析: thread 在论坛里代表主题帖；而回复贴是叫 reply 。 一个主题帖下面可以跟许多回复，就好象被绳子串起来一样，所以使用 thread 这个名称也带有比喻意义。

nt getPriority() 　　返回线程的优先级。 这个难道不是Thread类的方法？ 请楼书删掉这个帖子的最佳答案 或直接删帖把 以免误导更多人....

http://dict.baidu.com/s?wd=thread这里有读音

线

最简单明了：斯ruai德

1、thread 线，读音：美/θred/；英/θred/。 2、释义:n.线；螺纹；思路；衣服；线状物；玻璃纤维；路线。vt.穿过；穿线于；使交织。vi.通过；穿透过。 3、例句：Im looking for a needle and thread.我在找一根针和线。

1、thread英[θred]美[θred]，n.(棉、毛、丝等的)线; 线索; 脉络; 思绪; 思路; 贯穿的主线; 线状物; 细细的一条; 系列相关信息，链式消息; 螺纹; 衣服;v.穿(针); 纫(针); 穿过; 通过; 穿行; 穿成串; 串在一起; 给…装入; 用…线缝。 2、[例句]The blue fabric was interwoven with red and gold thread.蓝布中交织着红色和金色的线。

thread的意思是：线。Thread，英文单词，名词、动词，作名词时意思是“线；螺纹；思路；衣服；线状物；玻璃纤维；路线”，作及物动词时意思是“穿过；穿线于；使交织”，作不及物动词时意思是“通过；穿透过”。短语搭配1、thread cutting螺纹加工装置。2、thread angle螺纹角；螺纹断面角；牙型角；螺纹牙形角度。3、TRIM THREAD剪线。4、coarse thread粗牙螺纹；粗牙；粗螺距；粗螺纹。5、embroidery thread绣花线；刺绣用线；刺绣线。双语例句1、The blue fabric was interwoven with red and gold thread.蓝布中交织着红色和金色的线。2、A ratchet mechanism transfers the thread from spool to bobbin.一种棘齿装置把线从线轴转到梭心上。3、It took me a long time to thread my way through the crowd.我花了很长时间才从人群中挤过去。4、The author skilfully draws together the different threads of the plot.作者娴熟地把情节的各种线索串联在一起。

这个词有时有含义，详细如下；有时没有任何含义，还是要根据具体语境能分析。供参考。1. N-VAR 可变名词(尤指用于缝纫的)细线，细丝 Thread or a thread is a long very thin piece of a material such as cotton, nylon, or silk, especially one that is used in sewing. 2. N-COUNT 可数名词主线;思路;脉络 The thread of an argument, a story, or a situation is an aspect of it that connects all the different parts together. 3. N-COUNT 可数名词线状物;一线 A thread of something such as liquid, light, or colour is a long thin line or piece of it. 4. N-PLURAL 复数名词衣服 You can refer to clothes as threads . 5. N-COUNT 可数名词螺纹 The thread on a screw, or on something such as a lid or a pipe, is the raised spiral line of metal or plastic around it which allows it to be fixed in place by twisting. 6. VERB 动词穿行;曲折穿过;蜿蜒 If you thread your way through a group of people or things, or thread through it, you move through it carefully or slowly, changing direction frequently as you move. 7. VERB 动词使(细长的物体)穿过;使穿进 If you thread a long thin object through something, you pass it through one or more holes or narrow spaces. 8. VERB 动词将(珠子等)穿起来 If you thread small objects such as beads onto a string or thread, you join them together by pushing the string through them. 9. VERB 动词穿(针) When you thread a needle, you put a piece of thread through the hole in the top of the needle in order to sew with it.

1、thread英[θred]美[θred]，n.(棉、毛、丝等的)线;线索;脉络;思绪;思路;贯穿的主线;线状物;细细的一条;系列相关信息，链式消息;螺纹;衣服;v.穿(针);纫(针);穿过;通过;穿行;穿成串;串在一起;给?装入;用?线缝。2、[例句]Thebluefabricwasinterwovenwithredandgoldthread.蓝布中交织着红色和金色的线。

你的问题太广泛了。去这里看吧：http://msdn.microsoft.com/zh-cn/library/system.threading.thread_members(v=VS.95).aspx每个属性和方法都有例子。

在一个Android 程序开始运行的时候，会单独启动一个Process。默认的情况下，所有这个程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的两种， 除此之外还有Content Provider和Broadcast Receiver）都会跑在这个Process。一个Android 程序默认情况下也只有一个Process，但一个Process下却可以有许多个Thread。在这么多Thread当中，有一个Thread，我们称之为UI Thread。UI Thread在Android程序运行的时候就被创建，是一个Process当中的主线程Main Thread， 主要是负责控制UI界面的显示、更新和控件交互。在Android程序创建之初，一个Process呈现的是单线程模型，所有的任务都在一个线程中运行。因此，我们认为，UI Thread所执行的每一个函数，所花费的时间都应该是越短越好。而其他比较费时的工作（访问网络，下载数据，查询数据库等），都应该交由子线程去执行，以免阻塞主线程。那么，UI Thread如何和其他Thread一起工作呢？常用方法是：1.诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。2.在子线程的状态发生变化时，我们需要更新UI。如果在子线程中直接更新UI,通常会抛出下面的异常：ERROR/JavaBinder(1029):android.view.ViewRoot$CalledFromWrongThreadException:Only the original thread that created a view hierarchy can touch its views.意思是，无法在子线程中更新UI。3.我们需要通过Handler物件，通知主线程Ui Thread来更新界面。如下: 3.1 首先创建一个Handler,来监听Message的事件：private final int UPDATE_UI = 1;private Handler mHandler = new MainHandler();private class MainHandler extends Handler {@Overridepublic void handleMessage(Message msg) {switch (msg.what) {case UPDATE_UI: {Log.i("TTSDeamon", "UPDATE_UI");showTextView.setText(editText.getText().toString());ShowAnimation();break;}default:break;}}}3.2private Handler mHandler = new Handler(){@Overridepublic void handleMessage(Message msg) {switch (msg.what) {case UPDATE_UI: {Log.i("TTSDeamon", "UPDATE_UI");showTextView.setText(editText.getText().toString());ShowAnimation();break;}default:break;}}}当子线程的状态发生变化，则在子线程中发出Message，通知更新UI。mHandler.sendEmptyMessageDelayed(UPDATE_UI, 0);4. 在我们的程序中，很多Callback方法有时候并不是运行在主线程当中的，所以如果在Callback方法中更新UI失败，也可以采用上面的方法。

SubThread是Thread的子类，子类构造方法调用父类构造方法

L：指的是左旋H：指的是配合公差带H级THREAD：指的是螺纹的英文意思。

1） start：用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。2） run：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.。

线形的抽象的线可以叫linethread是缝衣服的线，实物的线。

Runnable接口和Thread类是java中实现多线程的两中方法。Thread类的构造方法有8个，但常用的只有4个，分别为：Thread类中的两个最主要的方法：（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。（2）start()—用于启动线程。实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过实现Runnable接口来创建并启动多线程的步骤：

最高 THREAD_PRIORITY_HIGHEST 线程在高于正常优先级上两级上运行。高于正常 THREAD_PRIORITY_ABOVE_NORMAL 线程在正常优先级上一级上运行。正常 THREAD_PRIORITY_NORMAL 线程在进程的优先级类上正常运行。低于正常 THREAD_PRIORITY_BELOW_NORMAL 线程在低于正常优先级下一级上运行。最低 THREAD_PRIORITY_LOWEST 线程在低于正常优先级下两级上运行。空闲 THREAD_PRIORITY_IDLE 对于实时优先级类线程在优先级16上运行对于其他优先级类线程在优先级1上运行。

thread作为名词时解释为：线、细丝、线索、螺纹等等。作为动词时意为：以线穿过、谨慎地穿过、蜿蜓前进、滴下成丝状等等。post作为名词时解释为：邮政、邮件、柱、职务、哨所、营地等等。作为动词时意为：贴出（通知等）、把…列入公布、使在岗位上、使充分了解、快速行进、邮寄等等。还可以作为副词意为：用邮寄、快速地。

threadn.线, 细丝, 线索, 思路, 螺纹n.线，纱；纤维线索；脉络；思路to lose the thread of one"s argument论点有失条理螺丝；螺纹vt.纫针，把线穿过（针孔）（把影片）装入 电影放映机stringn.线, 细绳, 一串, 一行v.排成一列

是fluent的UDF里的吗？

"线"在英文中的表达方式是 "thread"。以下是关于 "thread" 的详细解释："Thread" 是指一种用于缝合、编织或裁缝的细长纤维。它通常由棉、丝、尼龙、聚酯纤维等材料制成。线在各种制作和修复活动中起到连接和固定的作用。以下是一些与 "thread" 相关的词语和表达方式：Sewing thread（缝纫线）：指用于缝制衣物、织品和其他纺织品的线。缝纫线通常是强度较高且耐用的，以便在缝合过程中保持牢固。例如："I need to buy some sewing thread to mend my torn shirt."（我需要买一些缝纫线来修补我的破衬衫。）"The sewing thread comes in a variety of colors to match different fabrics."（缝纫线有各种颜色可以搭配不同的织物。）Embroidery thread（刺绣线）：指用于刺绣和绣花的特殊线。刺绣线通常是色彩鲜艳且有光泽的，以便在绣花过程中产生丰富的效果。例如："She used gold embroidery thread to add intricate details to the design."（她使用了金色的刺绣线来为设计增添精细的细节。）"The embroidery thread is available in different thicknesses for various stitching techniques."（刺绣线有不同的粗细，适用于各种刺绣技术。）

1.进程和线程的区别 　　通俗一点说，进程就是程序的一次执行，而线程可以理解为进程中的执行的一段程序片段。 　　用一点文词说就是，每个进程都有独立的代码和数据空间（进程上下文）；而线程可以看成是轻量级的进程。一般来讲（不使用特殊技术），同一进程所产生的线程共享同一块内存空间。 　　同一进程中的两段代码是不可能同时执行的，除非引入线程。 　　线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除。 　　线程占用的资源要少于进程所占用的资源。 　　进程和线程都可以有优先级。 　　在线程系统中进程也是一个线程。可以将进程理解为一个程序的第一个线程。 　　多进程——在操作系统中，能同时运行多个任务（程序）。 　　多线程——在同一应用程序中，有多个顺序流同时执行。 　　2.通过铁路售票程序来理解实现多线程的两种方法：通过java.lang.Thread类和通过Runnable接口 　　java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？ 　　为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。 　　我们首先这样编写这个程序： 　　public class ThreadDome1{ 　　public static void main(String[] args){ 　　ThreadTest t = new ThreadTest(); 　　t.start(); 　　t.start(); 　　t.start(); 　　t.start(); 　　} 　　} 　　class ThreadTest extends Thread{ 　　private int ticket = 100; 　　public void run(){ 　　while(true){ 　　if(ticket > 0){ 　　System.out.println(Thread.currentThread().getName() + 　　"is saling ticket" + ticket--); 　　}else{ 　　break; 　　} 　　} 　　} 　　} 　　上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start（）方法，结果只有一个线程。 　　我们接着修改ThreadDemo1，在main方法中创建四个Thread对象： 　　public class ThreadDemo1{ 　　public static void main(String[] args){ 　　new ThreadTest().start(); 　　new ThreadTest().start(); 　　new ThreadTest().start(); 　　new ThreadTest().start(); 　　} 　　} 　　class ThreadTest extends Thread{ 　　private int ticket = 100; 　　public void run(){ 　　while(true){ 　　if(ticket > 0){ 　　System.out.println(Thread.currentThread().getName() + 　　" is saling ticket" + ticket--); 　　}else{ 　　break; 　　} 　　} 　　} 　　} 　　这下达到目的了吗？ 　　从结果上看每个票号都被打印了四次，即四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。 　　经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。 　　public class ThreadDemo1{ 　　public static void main(String[] args){ 　　ThreadTest t = new ThreadTest(); 　　new Thread(t).start(); 　　new Thread(t).start(); 　　new Thread(t).start(); 　　new Thread(t).start(); 　　} 　　} 　　class ThreadTest implements Runnable{ 　　private int tickets = 100; 　　public void run(){ 　　while(true){ 　　if(tickets > 0){ 　　System.out.println(Thread.currentThread().getName() + 　　" is saling ticket " + tickets--); 　　} 　　} 　　} 　　} 　　上面的程序中，创建了四个线程，每个线程调用的是同一个ThreadTest对象中的run（）方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。 　　可见，实现Runnable接口相对于继承Thread类来说，有如下显著的好处： 　　（1）适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。 　　（2）可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。 　　（3）有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象时，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。一个进程可以有很多线程，每条线程并行执行不同的任务。在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。扩展资料：线程与进程的区别可以归纳为以下4点：1）地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。2）通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。3）调度和切换：线程上下文切换比进程上下文切换要快得多。4）在多线程OS中，进程不是一个可执行的实体。参考资料来源：百度百科-线程

鸡跟鸡蛋的关系，Runnable是蛋，放到Thread里就变成鸡了。