Java创建线程的三种方式

线程启动

Thread

一、继承Thread类创建线程类

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

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

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

//创建线程对象,target为继承Target的子类,name为方法,或者直接new Thread的子类
Thread newThread = new Thread(target,name);
//线程启动
newThread.start();

Runnable

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

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

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

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

//创建线程对象,target为实现Runnable接口的实现类,name为方法
Thread newThread = new Thread(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 extends Thread {
    //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
    public volatile boolean exit = false; 

    @Override
    public void run() {
        ServerSocket serverSocket = new ServerSocket(8080);
        while(!exit){
            serverSocket.accept(); //阻塞等待客户端消息
            /*todo 业务判断是否满足条件,改变exit状态,线程执行完毕*/
        }
    }
    
    public static void main(String[] args) {
        ServerThread t = new ServerThread();
        t.start();
        ...
        t.exit = true; //修改标志位，退出线程
    }
}

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

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

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

        Thread thread = new Thread(){                   
            @Override                                   
            public void run() {         
           
            }                                
        };        
        //启动线程                                      
        thread.start();   
        //强制终止线程
        thread.stop();                                      

interpret中断线程(推荐)

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

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

public class ThreadInterrupt extends Thread
{
    public void run()
    {
        //线程处于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) throws Exception
    {
        Thread thread = new ThreadInterrupt();
        //子线程运行
        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方法的线程持有锁，它并不会释放锁。