一：线程的概念
多线程是个有意思的概念，一个应用程序，比如酷我音乐或者某个游戏，是一个进程，然后cpu给该进程
分配内存空间，如果电脑内存空间有限，而且运行的程序比较多时就会比较卡，一个进程可能有多个线程
执行，比如游戏中，多个任务，建筑物等都是线程在操作，在单核处理器的情况下，是并发执行的，cpu给
每个线程随机分配时间片，得到时间片的那个任务执行，由于切换的频率比较快，所以用户看起来是一起
执行的。在多核处理器的情况下，是并行的，确实可以一起执行，所以多线程的好处就是不必考虑电脑是否多核，
确实可以提高执行效率。
下面看一个简单的例子如下：
//实现倒计时功能
class CountDown implements Runnable{
private int countDown = 10; //用来计数
public static int taskCount = 0; //用来标记实例，从零开始
public final int id = taskCount++; //定义为final类型，不可修改
public CountDown(){}
public CountDown(int countDown){
this.countDown = countDown;
}
public String getStatus(){
return "#"+id+ "("+(countDown>0?countDown:"liftOff!")+")";
}
@Override
public void run() {
while(countDown-->0){
System.out.println(getStatus());
}
}
}
实现一个简单的倒计时功能，countDown用来计数，id用来标记访问实例，在main方法中调用run：
public class TestThread2 {
public static void main(String[] args) {
CountDown countDown = new CountDown();
countDown.run();
}
}
执行结果：
#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(liftOff!)
顺序执行，实际上上面的执行并没有涉及到线程，计数的执行都是在main线程中执行的，如果想实现多线程执行，就必须
把上面的任务依附到某个线程上。
二：创建线程的两种方式
1：继承Thread
// 创建线程方式一
class MyThread extends Thread {
public void run() {
for (int index = 0; index < 100; index++) {
System.out.println(Thread.currentThread().getName() + ":::" + index);
}
}
}
public class TestThread1 {
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();
for (int index = 0; index < 10; index++) {
System.out.println(Thread.currentThread().getName() + ":::" + index);
}
}
}
Thread-0:::0 Thread-0:::1 Thread-0:::2 main:::0 Thread-0:::3 Thread-0:::4 Thread-0:::5 Thread-0:::6 Thread-0:::7 Thread-0:::8 Thread-0:::9 main:::1 main:::2 main:::3 main:::4 main:::5 main:::6 main:::7 main:::8 main:::9
从运行结果可以看出，main线程和Thread0线程随机获取cpu时间片执行任务！
//创建线程方式二
class MyRun implements Runnable{
@Override
public void run() {
for (int index = 0; index < 100; index++) {
System.out.println(Thread.currentThread().getName() + ":::" + index);
}
}
}
public class TestThread1 {
public static void main(String[] args) {
Runnable run = new MyRun();
Thread thread = new Thread(run);
thread.start();
for (int index = 0; index < 10; index++) {
System.out.println(Thread.currentThread().getName() + ":::" + index);
}
}
}
main:::0 Thread-0:::0 Thread-0:::1 main:::1 Thread-0:::2 Thread-0:::3 main:::2 Thread-0:::4 Thread-0:::5 main:::3 Thread-0:::6 main:::4 main:::5 main:::6 main:::7 Thread-0:::7 Thread-0:::8 Thread-0:::9 main:::8 main:::9
运行结果类似上面，所以也是多线程执行
三：线程池的使用
如果需要执行主线程之外的线程时，可以用上面的方式创建线程，但是如果并发的任务比较多时，频繁的创建和销毁线程会消耗过多的资源
所以最好的选择是使用线程池，在使用的时候由线程池分配，使用完成由线程池回收掉
1:没有返回值的线程池
newCachedThreadPool 、newFixedThreadPool、newSingleThreadPool这是几种常见的线程池，第一种是线程池是无界的，但是内存
的资源是有限的，一般会有限制，第二种是固定长度线程池，在创建线程池的时候就指定线程的长度，第三种只会创建一个线程，如果第二种
的参数为1就是第三种
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
for(int i=0;i<5;i++){
service.execute(new CountDown());
}
service.shutdown();
}
#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(liftOff!) #2(9) #2(8) #1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(liftOff!) #4(9) #4(8) #4(7) #4(6) #4(5) #4(4) #4(3) #4(2) #4(1) #4(liftOff!) #2(7) #2(6) #2(5) #2(4) #2(3) #2(2) #2(1) #2(liftOff!) #3(9) #3(8) #3(7) #3(6) #3(5) #3(4) #3(3) #3(2) #3(1) #3(liftOff!)
从运行结果可以看出，随机放入5个执行任务到线程池中，然后这5个任务随机抢夺cpu的执行权
newFixedThreadPool和newCacheThreadPool的用法比较类似，cache是第一选择，如果有问题可以选择fixed，对于第三种
newSingleThreadPool，只有一个线程，如果对给它太多的任务，它会阻塞，然后顺序执行每一个任务：
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for(int i=0;i<5;i++){
service.execute(new CountDown());
}
service.shutdown();
}
#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(liftOff!) #1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(liftOff!) #2(9) #2(8) #2(7) #2(6) #2(5) #2(4) #2(3) #2(2) #2(1) #2(liftOff!) #3(9) #3(8) #3(7) #3(6) #3(5) #3(4) #3(3) #3(2) #3(1) #3(liftOff!) #4(9) #4(8) #4(7) #4(6) #4(5) #4(4) #4(3) #4(2) #4(1) #4(liftOff!)
这是没有返回值的线程池的用法，这种方式在需要异步调用的时候使用，同步调用的时候需要用到有返回值的线程池
2：有返回值的线程池
如果想让多线程执行完毕后，将结果返回，则需要实现Callable而不是Runnable，重写call()方法，而不是run()方法
//创建有返回值的线程池
class MyCall implements Callable<Integer>{
private int id;
public MyCall(int id){
this.id = id;
}
@Override
public Integer call() throws Exception {
return id;
}
}
public class TestThread3 {
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(5);
List<Future<Integer>> result = new ArrayList<Future<Integer>>();
for(int i=0;i<5;i++){
Future<Integer> future = exec.submit(new MyCall(i));
result.add(future);
}
for(Future<Integer> future:result){
Integer i;
try {
i = future.get();
System.out.println(i);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally{
exec.shutdown();
}
}
}
}
0 1 2 3 4
多线程执行完任务后，最后将结果返回，其中get()会阻塞线程，起到计数器的作用，如果有一个线程没有执行完毕，那么就会一直阻塞
不会结束。
模拟如下：
修改call()方法代码如下：
public Integer call() throws Exception {
if(3==id){
Thread.sleep(3000);
}
return id;
}
那么在运行的时候，就会在id=3处阻塞，3后面的任务都不会执行，直到3执行结束。
今天多线程的知识就总结到这里了，后面继续......