怎么创建多线程（js 创建多线程的方法 Worker）

本文目录

• js 创建多线程的方法 Worker
• 多线程有哪些实现方式
• thread new thread 怎么创建很多线程
• 实现多线程都有哪几种方法
• c语言中怎样创建多线程
• 创建多线程有几种方法
• 区别Java线程与进程，如何创建线程
• Vivox9的多线程怎么开
• 创建线程的几种方式

js 创建多线程的方法 Worker

Worker 支持主流的浏览器 IE10 以下不支持 a.js 内容 var i =0 setInterval((function () { postMessage(i++) }),1000) 使用 postMessage 向主线程 传送消息 var worker =new Worker(’a.js’) // 写入需要引入的 js console.log(worker) worker.onmessage =function () { console.log(event.data) } //用于关闭worker线程   worker.terminate();

多线程有哪些实现方式

java多线程的几种实现方式：1.继承Thread类，重写run方法2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target3.通过Callable和FutureTask创建线程4.通过线程池创建线程 （上一篇已经讲过了）前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果 后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

thread new thread 怎么创建很多线程

可以这样class MyThread extends Thread{ public void run(){ System.out.println("Mythread 线程");}}MyThread t = new Mythread();t.start();或者这样Thread t = new Thread(new Runnabel(){ public void run(){ System.out.println("Mythread 线程");}});t.start();

实现多线程都有哪几种方法

1：UI线程。这个线程是操作系统自动创建的，你画了个winform，那么程序一启动，自然有了这么个线程。值得注意的是，你添加一个Timer控件，现实的多线程，实际上，依然在UI线程里。只是定时被Timer夺去控制权而已，本质上依然是单线程。另一个线索也可以论证：本来非UI线程想更新UI界面，是需要利用delegate,involk等来实现的，但是在timer控件的线程里，是不需要的。2：Threadthread=newThread(obj.functionName);thread.start();这样自定义的线程是真正的多线程，它的使用也是最灵活的。不像Timer线程，精确度只有50ms。值得注意的是：如果需要启动的线程函数是带输入参数的，怎么？有两个法：A:你不是启动obj对象里的函数吗？在thread.start();之前，你先添加这句话MyObjectobj=newMyObject(inta,intb);这样，obj.functionName函数里可以直接使用a和b了。还有个方法，就是利用委托封装函数，然后thread.start(参数);具体代码如下：args){Threadthread=newThread(myStaticParamThreadMethod);thread.Start("通过委托的参数传值");}3：利用threadpool线程池技术。threadpool的主要原理是池里面的线程不会完成一个任务就消亡，而是会继续执行其他的任务，这减少了线程的消亡和生成的代价。主要是ThreadPool.QueueUserWorkItem()和ThreadPool.RegisterWaitForSingleObject（···）两个静态函数。具体如下：QueueUserWorkItem的使用：staticvoidThreadProc(ObjectstateInfo){Console.WriteLine("Hellofromthethreadpool.");}Main函数里ThreadPool.QueueUserWorkItem(newWaitCallback(ThreadProc));即可。（注意WaitCallback系统委托），它的功能就像第2种方法里提到的newthread。那么RegisterWaitForSingleObject是干什么的呢？这个方法的做用是向线程池添加一个可以定时执行的方法。有点像第一种方法里提到的timer线程，却不属于UI线程。具体的使用如下：AutoResetEventwait=newAutoResetEvent(false);objectstate=newobject();ThreadPool.RegisterWaitForSingleObject(wait,newWaitOrTimerCallback(test),state,5000,false);//5000是间隔调用的时间，也就是wait变量卡住的timeout时间（我觉得内部是这样实现的）wait.Set();//如果有set这句话，那么第一次执行不用等5秒，则直接执行目标函数，否则没这句话，第一次执行要等5秒的。还有一个要注意：我平常使用的是ManualResetEvent，但在threadpool里，首先要选的是AutoResetEvent，因为AutoResetEvent能自动reset，所以下一次间隔来了，又要重新等待5秒钟，达到定时器的目的。如果是ManualResetEvent，要么一次执行不了（初始值为false），要么不间断的玩命执行。ManualResetEvent和AutoResetEvent的另一个重要区别是前者能一次唤醒多个线程，而后者一次只能唤醒一个线程。其实RegisterWaitForSingleObject函数的使用有点想我封装好的MyTimer类的实现了：我里面的while死循环里用了个wait.waitone(2000,false);即可。对了，说到这里，RegisterWaitForSingleObject函数实现的定时器，如果手动停止呢？这要用到Unregister函数：RegisteredWaitHandlerw=ThreadPool.RegisterWaitForSingleObject(wait,newWaitOrTimerCallback(test),state,3000,false);rw.Unregister(wait);嗯讨论了这么多线程的东西，干脆再说一个小点：Thread.IsBackground=true的时候，指示该线程为后台线程。后台线程将会随着主线程的退出而退出

c语言中怎样创建多线程

/*这是我写的最简单的多线程程序，看懂不？*/\x0d\x0a#include \x0d\x0a#include \x0d\x0a//#include \x0d\x0a\x0d\x0aDWORD WINAPI ThreadProc1( LPVOID lpParam ) \x0d\x0a{\x0d\x0a\x0d\x0a int i=0,j=0;\x0d\x0a while(1)\x0d\x0a {\x0d\x0a printf("hello,this thread 1 ...\n");\x0d\x0a \x0d\x0a //延时\x0d\x0a for(i=0;i《200000000;i++)\x0d\x0a {\x0d\x0a ;\x0d\x0a }\x0d\x0a }\x0d\x0a} \x0d\x0a\x0d\x0aDWORD WINAPI ThreadProc2( LPVOID lpParam ) \x0d\x0a{\x0d\x0a\x0d\x0a int i=0,j=0;\x0d\x0a while(1)\x0d\x0a {\x0d\x0a printf("hello,this thread 2 ...\n");\x0d\x0a \x0d\x0a //延时\x0d\x0a for(i=0;i《200000000;i++)\x0d\x0a {\x0d\x0a ;\x0d\x0a }\x0d\x0a }\x0d\x0a} \x0d\x0a\x0d\x0avoid main()\x0d\x0a{\x0d\x0a int i=0;\x0d\x0a //创建线程1\x0d\x0a CreateThread( \x0d\x0a NULL, // default security attributes\x0d\x0a 0, // use default stack size \x0d\x0a ThreadProc1, // thread function \x0d\x0a NULL, // argument to thread function \x0d\x0a 0, // use default creation flags \x0d\x0a NULL); // returns the thread identifier \x0d\x0a\x0d\x0a //创建线程2\x0d\x0a CreateThread( \x0d\x0a NULL, // default security attributes\x0d\x0a 0, // use default stack size \x0d\x0a ThreadProc2, // thread function \x0d\x0a NULL, // argument to thread function \x0d\x0a 0, // use default creation flags \x0d\x0a NULL); // returns the thread identifier\x0d\x0a\x0d\x0a //让主线程进入循环，主线程若退出，子线程1，2会被系统“杀死”\x0d\x0a while(1)\x0d\x0a {\x0d\x0a printf("hello,this thread 0 ...\n");\x0d\x0a \x0d\x0a //延时\x0d\x0a for(i=0;i《200000000;i++)\x0d\x0a {;}\x0d\x0a\x0d\x0a }\x0d\x0a}

创建多线程有几种方法

1、通过继承Thread类创建线程

(1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。(2).直接创建一个ThreadTest类的对象，也可以利用多态性，变量声明为父类的类型。

(3).调用start方法，线程启动，隐含的调用run()方法。

 view plain copy

• public class ThreadTest extends Thread{  

• public void run(){  

• for(int i=0;i《=10;i++){  

• System.out.println(i);  

• }         

• }  

• public static void main(String args) {  

• ThreadTest thread1=new ThreadTest();  

• ThreadTest thread2=new ThreadTest();  

• thread1.start();  

• thread2.start();  

• }  

• }  

2、通过实现Runnable接口创建线程

(1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。

(2).创建Runnable接口实现类的对象。

(3).创建一个ThreadTest类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承）

(4).调用Thread对象的start()方法，启动线程

 view plain copy

• public class ThreadTest implements Runnable{  

• @Override  

• public void run() {  

• for(int i=0;i《=10;i++){  

• System.out.println(i);  

• }     

• }  

• public static void main(String args) {  

• ThreadTest threadTest=new ThreadTest();  

• Thread theard=new Thread(threadTest);  

• theard.start();  

• }  

• }  

3.通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

 view plain copy

• public class ThreadTest implements Callable《Integer》{  

• @Override  

• public Integer call() throws Exception {  

• int count =0;  

• for(int i=0;i《=10;i++){  

• count=count+i;  

• }  

• return count;     

• }  

• public static void main(String args) throws InterruptedException, ExecutionException {  

• ThreadTest test=new ThreadTest();  

• FutureTask《Integer》 thread = new FutureTask《》(test);  

• new Thread(thread,"有返回值的线程").start();    

• System.out.println(thread.get());  

• }  

• }  

使用实现Runnable接口方式创建线程可以共享同一个目标对象（TreadDemo1 tt=new TreadDemo1();），实现了多个相同线程处理同一份资源。

然后再看一段来自JDK的解释：

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments calledrun.

This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example,Runnable is implemented by classThread. Being active simply means that a thread has been started and has not yet been stopped.

In addition, Runnable provides the means for a class to be active while not subclassingThread. A class that implementsRunnable can run without subclassingThread by instantiating aThread instance and passing itself in as the target. In most cases, theRunnable interface should be used if you are only planning to override therun() method and no otherThread methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.

采用实现Runnable、Callable接口的方式创见多线程时，优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

• 编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

采用继承Thread类方式：（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。采用实现Runnable接口方式：（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

区别Java线程与进程，如何创建线程

【答案】：多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响。线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。对线程的综合支持是Java技术的一个重要特色。它提供了thread类、监视器和条件变量的技术。虽然Macintosh，Windows NT，Windows 9等操作系统支持多线程，但若要用C或C++编写多线程程序是十分困难的，因为它们对数据同步的支持不充分。1)public class mythread extends Applet implements Runnable(小应用或已经是某个类的子类时)2)继承类Threadpublic class mythread extends Thread3)上述两种方法中都可用类Thread产生线程的对象Thread newthread；4)创建并启动线程newthread=new Thread(this);newthread.start();5)run方法是运行线程的主体，启动线程时，由Java直接调用public void run()6)停止线程，由小应用程序的stop调用线程的stop newthread.stop()7)sleep方法的作用，暂停线程的执行，让其他线程得到机会，sleep要丢出异常，必须抓住。Try{sleep(100)}catch(InterruptedException e){}

Vivox9的多线程怎么开

要开启一个多线程有两种方法：1、继承 Thread 类通过继承 Thread 类的方式实现多线程有4个步骤：create 一个类，让它继承 Thread 类重写 Thread 类里面的 run 方法，把需要执行的代码块放在 run 方法体内在主线程（主程序）内创建该类的对象用该对象调用 start 方法例子：package multiThread; public class jichengThread { public static void main(Stringargs){myThread mt = new myThread();mt.start();for(int i=0;i《1000;i++)System.out.println("主线程程序在执行.......");} } class myThread extends Thread{public void run(){for(int i=0;i《1000;i++)System.out.println("子线程程序在执行.......");}}执行结果：可以看到两个线程在同时执行但是有时候即使开启了一个多线程（开启多线程就是CPU在执行主程序的时候，同时分配一些空间执行子程序），但是还是看不到两个线程在同时执行，那有可能是主线程的程序执行时间太短，没有看到交替执行的结果，比如在 for 循环里面把循环的次数减小到10，就看不到交替执行的结果，但其实还是多线程除了创建两个类之外，还可以用匿名内部类的方式继承 Thread 类，重写 Thread 里面的run 方法，调用 start() 方法，实现多线程，如下：（匿名内部类就是创建一个类的对象，并不给其赋给对应的引用，如下面的 new Thread() 创建了一个 Thread 的对象，米有给其赋给一个引用，而 new Thread 后面跟小括号、大括号，表示该类继承Thread类，并创建了一个Thread类的子类对象，里面的 run 方法表示重写该方法，最终相当于创建了一个 Thread 类的对象，再调用 start 方法执行线程）package multiThread; public class nimingneibuleishixian { public static void main(String args) {new Thread(){@Overridepublic void run() {for(int i=0;i《1000;i++)System.out.println("子线程在执行....");}}.start(); for(int i=0;i《1000;i++){System.out.println("主线程在执行....");}}}运行结果：2、实现 Runable 接口通过该方法实现多线程的步骤如下：创建一个类，实现Runnable 接口重写 run 方法（注意：run 方法是 Runnable 接口里面唯一的方法，Thread 类也是实现了 Runnable 接口）创建该类的一个对象调用 Thread 类的有参构造，把上一步创建的对象作为参数传递，创建 Thread 类的一个对象调用该对象的 start 方法例子：package multiThread; public class shixianRunable { public static void main(String args) { myRunable mr = new myRunable();Thread t = new Thread(mr);t.start();for(int i=0;i《1000;i++)System.out.println("主线程程序在执行....");}} class myRunable implements Runnable{ public void run(){for(int i=0;i《1000;i++)System.out.println("子线程程序在执行.....");}}同样也可以使用匿名内部类实现 Runnable 接口的方式实现多线程：package multiThread; public class nimingneibuleishixian { public static void main(String args) { //创建一个 Thread 的子类对象new Thread( //把这里面的东西作为 Thread 的构造参数传入进去new Runnable(){@Overridepublic void run() {for(int i=0;i《1000;i++)System.out.println("子线程在执行....");}}).start();for(int i=0;i《1000;i++){System.out.println("主线程在执行....");}}}由于用 new Runnable() 的方式是创建的 Runnable 的子类对象，但是 Runnable 的子类对象里面没有 start 方法，该方法只在 Thread 里面有，所以要把其作为一个参数传递给 Thread 的构造函数，再调用 start 开启线程**对实现 Runnable 方式创建线程的一点理解：编译的时候，调用的是 Runnable 接口里面的方法，在实际运行的时候，调用的是 myRunnable 里面的方法在实际应用中，由于java 不支持多继承，所以当一个类没有继承一个父类的时候，应该优先考虑使用继承 Thread 类的方式，因为这种方式简单，如果继承了其他的父类，就要用实现 Runnable 接口的方式了

创建线程的几种方式

Java中创建线程主要有三种方式：

一、继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。

二、通过Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。

三、通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。