java如何写线程外部类_Java创建线程的三种方式

线程启动

Thread

一、继承Thread类创建线程类

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

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

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

//创建线程对象,target为继承Target的子类,name为方法,或者直接new Thread的子类

Thread newThread = newThread(target,name);//线程启动

newThread.start();

Runnable

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

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

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

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

//创建线程对象,target为实现Runnable接口的实现类,name为方法

Thread newThread = newThread(target,name);//线程启动

newThread.start();

Callable

三、通过Callable和Future创建线程

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

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

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

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

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

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

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

劣势是：

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

使用继承Thread类的方式创建多线程时优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类

线程停止

标志位终止线程

使用标志位让线程自己执行完毕.

public class ServerThread extendsThread {//volatile修饰符用来保证其它线程读取的总是该变量的最新的值

public volatile boolean exit = false;

@Overridepublic voidrun() {

ServerSocket serverSocket= new ServerSocket(8080);while(!exit){

serverSocket.accept();//阻塞等待客户端消息

/*todo 业务判断是否满足条件,改变exit状态,线程执行完毕*/}

}public static voidmain(String[] args) {

ServerThread t= newServerThread();

t.start();

...

t.exit= true; //修改标志位，退出线程

}

}

stop方法强制终止(不推荐)

调用线程的stop()方法会立刻停止run()方法中剩余的全部工作，包括在catch或finally语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。

调用线程的stop()方法会立即释放该线程所持有的所有的锁，导致数据得不到同步，出现数据不一致的问题。

Thread thread = newThread(){

@Overridepublic voidrun() {

}

};//启动线程

thread.start();//强制终止线程

thread.stop();

interpret中断线程(推荐)

interrupt()方法的作用是用来停止线程，但intermpt() 方法的使用效果并不像循环结构中break语句那样，可以马上停止循环。调用 intermpt()方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

在非阻塞状态下，可以通过Thread.currentThread().isInterrupted()判断当前线程是否被中断；在阻塞状态下，interrupt中断会报InterruptedException异常(sleep、wait、)，通过捕获异常在catch中break跳出循环。

public class ThreadInterrupt extendsThread

{public voidrun()

{//线程处于RUNNABLE状态时,isInterrupted()方法判断当前线程是否被中断

while(!Thread.currentThread().isInterrupted()){try{

System.out.println(Thread.currentThread().getName()+"正在执行");

sleep(5000); //延迟5秒,线程处于阻塞状态

}catch (InterruptedException e) //{

System.out.println(Thread.currentThread().getName()+"线程"+e.getMessage());break; //捕获阻塞时线程被interrupt的异常

}

}

}public static void main(String[] args) throwsException

{

Thread thread= newThreadInterrupt();//子线程运行

thread.start();

System.out.println("在5秒之内按任意键中断子线程!");

System.in.read();

thread.interrupt();//执行中断

thread.join(); //主线程等待子线程执行完毕

System.out.println("主线程退出!");

}

}

线程其他注意事项

suspend/resume

suspend()方法执行的时候这个线程会被挂起而不释放任何锁的资源，直到这个线程重新调用resume()，这个线程才会重新执行。所以suspend和resume方法已经被废弃掉了。

join

join()方法，任何地方当调用了t.join()，其他线程就必须要等待线程t执行完毕后，才能继续执行其他线程。这里其实是运用了Java中最顶级对象Object提供的方法wait()。wait()方法用于线程间通信，它的含义是通知一个线程等待一下，让出CPU资源，注意这里是会放弃已经占有的资源的。直到t线程执行完毕，再调用notify()唤醒当前正在运行的线程。

wait/notify、notifyall

wait并不是Thread的方法而是object的方法，这也意味着everyone can use them，

在线程A中，调用了obj.wait(),那么A线程就会停止执行，转为等待状态，那么要等待到何时才结束呢，等到有其他线程调用obj.notify()/obj.notifyall();注意哦，是别人调用notify,而不是等待线程调用的。

当一组线程中都调用了同一个对象的obj.wait()，则线程会进入一个阻塞的线程队列，当有线程调用obj.notify的时候，则会随机挑选一个并将其唤醒，而且这个是一个不公平的过程。而notifyall(),则会把在等待队列中的全部唤醒。

wait/notify、notifyall这一对方法并不是随便任意时候都可以调用的，而是应该在synchronized语句中，目标对象都应该先获得监视器。

sleep

Object.wait()和Thread.sleep()方法都可以让线程等待若干时间。但是sleep()不可以被唤醒；wait()会释放目标对象的锁，而Thread.sleep()不会释放任何资源。

调用sleep方法的对象会停止你设置的时长，(所以sleep()方法必须有时长的参数)，sleep主要是为了暂停当前线程，把cpu片段让出给其他线程，延缓当前线程的执行。但是如果调用sleep方法的线程持有锁，它并不会释放锁。