多线程，字面意思

Posted 2021-04-21 码省理工

今天聊聊多线程

阅读文本大概需要 3 分钟。建议收藏，多敲代码。

1

概念

1.1 什么是线程

一个线程要执行任务,必须得有线程。

一个进程(程序)的所有任务都在线程中执行的。

一个线程执行任务是串行的,也就是说一个线程,同一时间内,只能执行一个任务。

1.2 多线程原理

同一时间,CPU只能处理1条线程,只有一条线程在工作(执行)。

多线程并发(同时)执行,其实质是CPU快速的在多线程之间调度(切换)。

1.3 如果线程过多,会怎样?

CPU在N多条线程中调度,会消耗大量的cpu资源。

每条线程被调度执行的频率越低(线程的执行效率低)。

1.4 多线程的优点

能适当提高程序的执行效率。

能适当提高资源的利用率(CPU 内存利用率等)。

1.5 多线程的缺点

创建线程是有开销的，ios下主要成本包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K）创建线程大约需要90毫秒的创建时间。如果开启大量的线程,会降低程序的性能。程序越多CPU的线程上的开销就越大。程序设计更加复杂:线程之间的通讯,多线程的数据共享。

1.6 主线程的主要作用

显示和刷新UI界面。处理UI事件(比如点击事件,滚动事件,拖拽事件等)。别将比较耗时的操作放在主线程中,会导致UI界面的卡顿。将耗时操作放在子线程(后台线程,非主线程)。

2

实现多线程的4种方案

Java中实现多线程主要有这四种方式：①继承Thread类；②实现Runnable接口；③实现Callable接口通过FutureTask包装器来创建Thread线程；④使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

2.1继承Thread类

Thread 类本质上是实现了 Runnable 接口的一个实例(可以自行查看 Thread 源码)，代表一个线程的实例。启动线程的唯一方法就是通过 Thread  类的start() 实例方法。start() 方法是一个native 方法，它将启动一个新线程，并执行 run() 方法。这种方式实现多线程很简单，通过自己的类直接 extend Thread ，并复写 run() 方法，就可以启动新线程并执行自己定义的 run() 方法。例如：（友情提示:代码可以右划）

public class ThreadDemo extends Thread{  //继承Thread
  
    private String ThreadName;  
    public ThreadDemo(String ThreadName){  
        this.ThreadName = ThreadName;  
    }  
    public void run(){  
        System.out.println("running--"+this.ThreadName+"---"+Thread.currentThread().getId());  
    }  
      
    public static void main(String[] args) {  
        ThreadDemo threadDemo = new ThreadDemo("ThreadDemo_one");  
        threadDemo.start();  
        ThreadDemo threadDemo1 = new ThreadDemo("ThreadDemo_two");  
        threadDemo1.start();  
    }  
}

2.2 实现Runnable接口

如果自己的类已经 extends 另一个类，就无法直接extends Thread，此时，可以实现一个 Runnable 接口，如下：

class RunnableDemo implements Runnable{  
    private Thread t;  
    private String threadName;  
    RunnableDemo(String threadName){  
        this.threadName = threadName;  
        System.out.println("创建---"+threadName);  
    }  
    public void run(){  
        System.out.println("running---"+threadName);  
        try {  
            for (int i = 0; i < 4; i++) {  
                  System.out.println("Thread: " + threadName + ", " + i);  
                    Thread.sleep(5000);  
            }  
        } catch (InterruptedException e) {  
             System.out.println("Thread " +  threadName + " interrupted.");  
        }  
         System.out.println("Thread " +  threadName + " exiting.");  
    }  
    public void start(){  
        System.out.println("starting---"+threadName);  
        if(t==null){  
            t = new Thread(this,threadName);  
            t.start();  
        }  
          
    }  
    public static void main(String[] args) {  
        RunnableDemo runnableDemo = new RunnableDemo("wq");  
        runnableDemo.start();  
        RunnableDemo runnableDemo1 = new RunnableDemo("css");  
        runnableDemo1.start();  
    }  
}

2.3 实现Callable接口

Callable 接口（也只有一个方法），FutureTask  是一个包装器，它通过接受 Callable  来创建，它同时实现了Future 和Runnable 接口。

public class CallableDemo implements Callable<Integer>{  
  
    public Integer call() throws Exception {  
           
        int i = 0;    
        for(;i<100;i++)    
        {    
            System.out.println(Thread.currentThread().getName()+" "+i);    
              
        }    
        return i;    
    }  
    public static void main(String[] args) {  
        CallableDemo call = new CallableDemo();  
        FutureTask<Integer> ft = new FutureTask<Integer>(call);  
//      new Thread(ft,"有返回值的线程").start();  
          for(int i = 0;i < 100;i++)    
            {    
                System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);    
                if(i==21)    
                {    
                    new Thread(ft,"有返回值的线程").start();    
                }    
            }    
         try {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e) {  
              
        } catch (ExecutionException e) {  
              
        }    
    }  
}

2.4. ExecutorService、Callable、Future

public class test {  
  
    public static void main(String[] args) {  
        ExecutorService threadPool = Executors.newFixedThreadPool(5);  
        // newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
        // newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
        // newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。  
        // newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。  
        List<Future> futureList= new ArrayList<Future>();  
        for (int i = 0; i <5; i++) {  
            Callable task = new TestCallable("wq"+i, "phone"+i);  
            Future<Object> f = threadPool.submit(task);  
            futureList.add(f);  
        }  
        threadPool.shutdown();  
        for (Future future : futureList) {  
            try {  
                System.out.println(future.get().toString());  
            } catch (Exception e) {  
                  
                e.printStackTrace();  
            }   
        }  
          
    }  
      
}  
class TestCallable implements Callable<Object>{  
    private String name;  
    private String phone;  
     TestCallable(String name,String phone){  
        this.name=name;  
        this.phone=phone;  
    }  
    public Object call() throws Exception {  
         System.out.println(name+"----"+phone);  
        return name+"--return--"+phone;  
    }  
      
}

3

其实，很多面试官都清楚，初级程序员对于多线程的掌握度几乎为零。但是面试环节中，很多面试官都会抱着试一试的态度去提问一两道多线程的题目。其目的不是为了难为面试者，也不是为了彰显面试的“高大上”，而是为了区分一般人才与优质人才。最后一点大家谨记：

在找工作的时候，除了做些相关面试和准备熟悉以前做的项目之外，还应该学习新的知识。毕竟，每多学一点，成功找到工作的机会就大一点。而且，IT这行，技术发展过于快速，如果没有学习新知识的动力，终究会被淘汰。

因为学习实在是很枯燥无味。学习是一个长期投资，短期很难道看到收益。所以学习这块最好可以给自己定一个目标，每天学习一点，慢慢的会达到的。如果没有动力的话，可以给自己设置奖励。这是可以激发学习的兴趣的。还有一点，今天能坐完的事情，绝对不要留给明天。毕竟，人都是有惰性的。你要相信你自己，今天的你能做的没有做，明天的你也不会做的。

---

基础要扎实

如果对您有帮助，欢迎点赞、关注、转发。