java多线程简单操作和实际项目开发如何写

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ClassExecutorService {

/**固定线程：cpu个数加一，让一个一直处于等待状态*/
private static ExecutorService pool = Executors.newFixedThreadPool(5);
/**
* newSingleThreadExecutor: 产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行
* newCachedThreadPool(): 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
* newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行
* newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行
* newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行
* */
/**单元测试*/
public static  void main(String args[]) throws InterruptedException, ExecutionException{
//execute(Runnable command)：执行Ruannable类型的任务.
pool.execute(new Runnable() {
public void run() {
System.out.println("多线程执行");
}
});
//内部类的调用方式方式
ClassExecutorService ces=new ClassExecutorService();
//submit(task)：可用来提交Callable或Runnable任务，并返回代表此任务的Future对象
pool.submit(ces.new A());
//有返回值的线程：
Future<?> re=pool.submit(ces.new B("执行完毕"));
System.out.println(re.get().toString());

pool.shutdown();
/**
* shutdown()：在完成已提交的任务后关闭服务，不再接受新任务
* shutdownNow()：停止所有正在执行的任务并关闭服务。
* isTerminated()：测试是否所有任务都执行完毕了。
* isShutdown()：测试是否该ExecutorService已被关闭
* */
}

/**该类要实现Runnable接口*/
class A implements Runnable{
public void run() {
System.out.println("类A执行");
try {
//线程休眠一秒Thread是类，也是实现Runnable
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

class B implements Callable<Object>{
String param="";
public B(String param) {
this.param=param;
}

public Object call() throws Exception {
return "返回值是："+param;
}
}

}