java 多线程的使⽤ 以及区别

package com.zidingview;

import androidx.appcompat.app.AppCompatActivity;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.TypedValue;

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

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        多线程的使用();
        线程工厂创建线程();
        线程池创建使用();
        返回值的线程池();
    }

    private void 返回值的线程池() {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return null;
            }
        };
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> submit = executorService.submit(callable);
        try {
            String s = submit.get();
            System.out.println(s);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private void 线程池创建使用() {
        Executor executor = Executors.newCachedThreadPool();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {

            }
        };
        executor.execute(runnable);
        ExecutorService executor1 = Executors.newFixedThreadPool(20);
        for (Bitmap bitmap : bitmaps) {
            executor.execute(bitmapProcessor(bitmap));
        }
        executor1.shutdown();
    }

    private void 线程工厂创建线程() {
        //新建一个工厂类 返回一个thread类
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        };
        //新建Runnable 为thread工厂创建thread 使用
        Runnable runnable = new Runnable() {
            @Override
            public void run() {

            }
        };
        Thread thread1 = threadFactory.newThread(runnable);
        thread1.start();
    }

    private void 多线程的使用() {
        //多线程的使用1
        Thread thread = new Thread() {
            @Override
            public void run() {
                // super.run() 就是判断里面 假如有Runnble 方法 就使用此方法
                super.run();
                System.out.println("多线程使用之 Thread");
            }
        };
        //开启线程
        thread.start();
        //多线程使用方法2
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程使用");
            }
        };
        Thread thread2 = new Thread(runnable);
        thread2.start();
    }


}

new Thread的弊端如下：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

2、Java 线程池

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

线程池的作用：

线程池作用就是限制系统中执行线程的数量。
     根 据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排 队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。