⑴ 创建多线程有几种方法
1、通过继承Thread类创建线程
(1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
(2).直接创建一个ThreadTest类的对象，也可以利用多态性，变量声明为父类的类型。
(3).调用start方法，线程启动，隐含的调用run()方法。
[java]view plain
{
publicvoidrun(){
for(inti=0;i<=10;i++){
System.out.println(i);
}
}
publicstaticvoidmain(String[]args){
ThreadTestthread1=newThreadTest();
ThreadTestthread2=newThreadTest();
thread1.start();
thread2.start();
}
}
2、通过实现Runnable接口创建线程
(1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
(2).创建Runnable接口实现类的对象。
(3).创建一个ThreadTest类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承）
(4).调用Thread对象的start()方法，启动线程
[java]view plain
{
@Override
publicvoidrun(){
for(inti=0;i<=10;i++){
System.out.println(i);
}
}
publicstaticvoidmain(String[]args){
ThreadTestthreadTest=newThreadTest();
Threadtheard=newThread(threadTest);
theard.start();
}
}
3.通过Callable和Future创建线程
（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
[java]view plain
<Integer>{
@Override
publicIntegercall()throwsException{
intcount=0;
for(inti=0;i<=10;i++){
count=count+i;
}
returncount;
}
publicstaticvoidmain(String[]args)throwsInterruptedException,ExecutionException{
ThreadTesttest=newThreadTest();
FutureTask<Integer>thread=newFutureTask<>(test);
newThread(thread,"有返回值的线程").start();
System.out.println(thread.get());
}
}
使用实现Runnable接口方式创建线程可以共享同一个目标对象（TreadDemo1 tt=new TreadDemo1();），实现了多个相同线程处理同一份资源。
然后再看一段来自JDK的解释：
TheRunnableinterface 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,Runnableis implemented by classThread. Being active simply means that a thread has been started and has not yet been stopped.
In addition,Runnableprovides the means for a class to be active while not subclassingThread. A class that implementsRunnablecan run without subclassingThreadby instantiating aThreadinstance and passing itself in as the target. In most cases, theRunnableinterface should be used if you are only planning to override therun()method and no otherThreadmethods. 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类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
⑵ java中实现多线程的方法有几种以及如何实现多线程
继承Thread类，然后重写run方法
实现Runnable接口，实现run方法
这是最常用的实现多线程的方式
⑶ java多线程方法有哪些
java实现线程常用到的方法有三种，供参考：
/**
*方法一：继承Thread类
*
*@authorqd
*
*/
{
@Override
publicvoidrun(){
System.out.println("run方法里面编写业务代码");
}
publicstaticvoidmain(String[]args){
MyThreadmyThread=newMyThread();
//调用start方法启动线程
myThread.start();
MyThread1myThread1=newMyThread1();
Threadthread=newThread(myThread1);
//调用start方法启动线程
thread.start();
}
}
/**
*方法二：实现Runnable接口
*
*@authorqd
*
*/
{
@Override
publicvoidrun(){
System.out.println("run方法里面编写业务代码");
}
}
/**
*方法三：实现Callable<T>接口优点：可以传参数，有返回值类型
*
*@authorqd
*
*/
<Integer>{
@Override
publicIntegercall()throwsException{
returnnull;
}
}
⑷ 多线程有几种实现方法
在java5以前实现多线程有两种方法（继承Thread类和实现Runnable接口）
它们分别为：
使用new Thread()和new Thread(Runnable)形式
第一种直接调用thread的run方法，所以，往往使用Thread子类，即new SubThread()。
第二种调用
Runnable的run方法。
第一种：
new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：
new Thread(){
public void run(){
}
}.start();
第二种：
new Thread(
new Runnable(){}
).start();
这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,
runnable的子类加上run方法后的代码如下：
new Thread(new Runnable(){
public void run(){
}
}
).start();
⑸ 多线程的几种实现方法详解
首先线程都是由Thread类来创建的，线程任务实现有2中方式
继承Thread类
实现Runnable类
还有一些线程的执行类，可以看看
⑹ 实现多线程都有哪几种方法
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(参数);具体代码如下：[ComVisibleAttribute(false)](Objectobj)//这个Thread类的构造方法的定义如下：publicThread(ParameterizedThreadStartstart);(Objectobj){Console.WriteLine(obj);}staticvoidMain(string[]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的时候，指示该线程为后台线程。后台线程将会随着主线程的退出而退出