创建多线程，除了继承Thread类之外，还可以实现Runnable接口
是因为在继承Thread类的时候 我们创建Thread类对象时，既创建线程对象，又开启线程，这样就会导致耦合性太高。在实现Runnable接口时，这个接口的子类对象就只负责开启线程，让Thread类对象只负责创建线程对象，就实现了分工，就降低了耦合性。
代码展示，首先创建一个类实现这个Runnable接口
public class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
代码展示，创建测试
public static void main(String[] args) {
//创建线程任务对象
MyRunnable my=new MyRunnable();
//创建线程对象
Thread t=new Thread(my);
Thread t2=new Thread(my);
//开启
t.start();
t2.start();
}
Thread构造方法将线程传进去。
这样就构成了Thread只负责创建线程对象，Runnable只负责创建线程
避免了继承Thread类的单继承的局限性
那我们为了实现多线程，去专门创建一个类，是不是有点浪费
那我们可以使用匿名内部类去实现多线程的操作
代码展示
public static void main(String[] args) {
//继承Thread类的方式
new Thread(){
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}.start();
//实现runnable
Runnable r=new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
};
//创建线程对象开启线程
new Thread(r).start();
}
上述代码中分别写了Thread类的匿名内部类的创建线程的方式和runnable匿名内部类的创建线程的方式
线程池
创建线程池可以指定创建几条线程，当开启线程的时候会自动给线程池中空闲的线程去执行
使用线程池的方式
（1）runnable接口
Executors类中有一个public static ExecutorService newFixedThreadPool(int nThreads) 方法，返回一个线程池对象
ExecutorService 线程池类中有一个 submit方法获取某一个线程对象
ExecutorService 线程池类中有一个shutdown方法 关闭线程池
代码展示
我们用runnable接口来实现
首先创建一个runnable子类继承这个runnable接口
public class MyRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
测试
public static void main(String[] args) {
//获取线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//描述线程任务
MyRunnable r=new MyRunnable();
//将线程任务对象交给线程池执行
es.submit(r);
es.submit(r);
es.submit(r);
//销毁线程池
es.shutdown();
}
上述代码中 线程池中只有两条线程，但是我们现编提交给线程池三条任务，那就会先执行完前两条线程任务之后再执行最后一条线程
（2）callable接口
该接口可以返回线程任务结束以后所产生的结果，该接口有一个泛型，就是该线程返回值是什么类型 这个泛型就写什么类型
Future<F>接口 用来记录线程任务执行完毕后产生的结果
get() 获取Future对象中封装的数据结果
代码展示，与上述步骤一样，只不过就是多了一个返回值
public class MyCallable implements Callable<String>{
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "abc";
}
}
创建测试
public static void main(String[] args) throws InterruptedException, ExecutionException {
//获得线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//创建线程任务
MyCallable c=new MyCallable();
//将线程任务交给线程池执行
Future<String> f=es.submit(c);
//获取返回值
String str=f.get();
System.out.println(str);
//销毁线程池
es.shutdown();
}
例举，用线程求1-n的和
创建一个类实现Callable接口
public class GetSum implements Callable<Integer>{
private int number;
public GetSum(int number) {
super();
this.number = number;
}
public GetSum() {
super();
}
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<=number;i++){
sum=sum+i;
}
return sum;
}
}
创建测试类
public static void main(String[] args) throws InterruptedException, ExecutionException {
//获取线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//创建线程任务
GetSum g=new GetSum(100);
GetSum gs=new GetSum(200);
//执行
Future<Integer> f1=es.submit(g);
Future<Integer> f2=es.submit(gs);
System.out.println(f1.get());
System.out.println(f2.get());
//关闭
es.shutdown();
}
这样就同时出了1-100的和 and 1-200的和