实现线程的方式
1.继承Thread类重写run();
Thread类中常用的两个构造方法是：
public Thread();//无参构造
public Thread(String threadName);//有参构造
完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，
将实现该功能的代码写入run()方法中，然后调用Thread类中的start()方法执行线程，等价于调用run()方法；
其中，Thread类不可以重复启动一个线程，也就是说，不可以调用已经启动的线程。强行调用，会抛出异常IllegalTreadStateException。
2.实现Runnable接口重写run();
实际上，Thread类实现了Runnable接口，其中的run()方法就是对Runnable接口中的run()方法的具体实现。
实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象和Thread对象相关联。适合多个相同的程序代码的线程去处理同一个资源。
Thread类有以下两个构造方法：使用这两个方法就可以将Runnable和Thread两个实例相关联。
public Thread（Runnable target);/traget是目标的意思
public Thread(Runnable target,String name);
使用Runnable接口启动线程的步骤：
建立Runnable对象；
使用参数为Runnable对象的构造方法创建Thread实例；
调用start()方法启动线程；
说到这里你可能也不明白怎么整，所以，请看下面的代码：
RET.java
package com;
public class RET implements Runnable {
private static int ticket = 10;
public RET() {
}
@Override
public void run() {//防止线程抢占资源
while(ticket>0) {
synchronized("") {//这样也行，定义锁也行，目前我还没发现这两种的区别，待定!!!!
if(ticket>0) {
System.out.println(Thread.currentThread().getName()+"卖出第"+ticket+"张票");
--ticket;
}else {
System.out.println("票卖完了");
}
}
}
}
}
App.java
package com;
public class App {
public App() {
RET r1 = new RET();
RET r2 = new RET();
new Thread(r1).start();
new Thread(r2).start();
new Thread(r2).start();//可以调用已经启动的线程,虽然可以这样，但是这条线程算是第三条线程了。不过不建议这样用，因为很混乱。
}
public static void main(String[] args) {
new App();
}
}
其中，如果一个类继承Thread，就不可以资源共享。但是如果实现了Runable接口的话，就可以实现资源共享。说到共享资源，就一定会抢占资源！要加锁！
而且，无论是继承Thread还是实现Runnable都不可以给方法加锁eg：public synchronized void run() {//防止线程抢占资源 因为这样加锁顶不住！！
都要static Object lock="locked";//这样加锁！！！！在改变数据的时候要synchronized(lock){在这里改变数据}！！！！
3.实现Callable接口重写call();
Callable接口实际上是属于Executor框架中的功能类，Callable接口与Runnable接口的功能类似，但提供了比Runnable更加强大的功能。
Callable可以在任务结束的时候提供一个返回值，Runnable无法提供这个功能
Callable的call方法分可以抛出异常，而Runnable的run方法不能抛出异常。
步骤：
自定义一个类实现java.util.concurrent包下的Callable接口
重写call方法
将要在线程中执行的代码编写在call方法中
创建ExecutorService线程池
将自定义类的对象放入线程池里面
获取线程的返回结果
关闭线程池，不再接收新的线程，未执行完的线程不会被关闭
看代码：
call.java
package com;
import java.util.concurrent.Callable;
public class call implements Callable<String> {//定义一个类实现Callable<V>接口
private static int ticket = 10;
private Object lock = "";
public call() {
}
@Override
public String call() throws Exception {
while(ticket>0) {
synchronized (lock) {
System.out.println(Thread.currentThread().getName()+"第"+ticket+"张");
--ticket;
}
}
return "没错，我执行完了上面的代码，还告诉你我完事了。";
}
}
App.java
package com; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class App { public App() { //创建ExecutorService线程池 ExecutorService threadPool = Executors.newSingleThreadExecutor(); //创建存储Future对象，用来存放ExecutorService的执行结果 Future<String> future = threadPool.submit(new call()); try { System.out.println("等待线程结束"); System.out.println(future.get()); } catch (Exception e) { e.printStackTrace(); }finally{
threadPool.shutdown();
}
}
public static void main(String[] args) {
new App();
}
}
但是，线程池怎么可能只放一个线程呢？？请看多个线程的办法，就是存到了数组里
cable.java
package com;
import java.util.concurrent.Callable;
public class cable implements Callable<String> {//定义一个类实现Callable<V>接口
private int a,b;
public cable(int a,int b) {
this.a=a;
this.b=b;
}
@Override
public String call() throws Exception {
System.out.println(a+b+" "+Thread.currentThread().getName());
Thread.sleep(1000);
return "没错，我执行完了上面的代码，还告诉你我完事了。";
}
}
App.java
package com;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class App {
public App() throws InterruptedException, ExecutionException {
//创建ExecutorService线程池
ExecutorService threadPool = Executors.newSingleThreadExecutor();
//创建存储Future对象的集合，用来存放ExecutorService的执行结果
ArrayList<Future<String>> future = new ArrayList<Future<String>>();
//举例子：开3个线程，将返回的Future对象放入集合中
future.add(threadPool.submit(new cable(1,2)));
future.add(threadPool.submit(new cable(4,5)));
future.add(threadPool.submit(new cable(7,8)));
for (Future<String> fs : future) {
//判断线程是否执行结束，如果执行结束就将结果打印
if (fs.isDone()) {
System.out.println("22222"+fs.get());
} else {
System.out.println("44444"+fs.toString());
}
}
//关闭线程池，不再接收新的线程，未执行完的线程不会被关闭
threadPool.shutdown();
System.out.println("main方法执行结束");
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
new App();
}
}
