java中如何创建一个线程？

⭐️最全线程知识汇总篇（线程生命周期、线程池创建、线程池实现原理、线程基本方法）⭐️
⭐️线程生命周期及五种状态
⭐️Java多线程之Executor框架
⭐️多线程分批处理数据

一、并发编程三要素

并发编程三要素

1、原子性:

一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么全部执行失败。
【synchronized 或 Lock或者java.util.concurrent.atomic里的原子变量类 】

2、有序性:

程序执行的顺序按照代码的先后顺序执行。（导致有序性的原因是编译优化，处理器可能会对指令进行重排序）【volatile、synchronized和Lock】

3、可见性:

一个线程对共享变量的修改,另一个线程能够立刻看到。缓存导致可见性问题。
【volatile、synchronized和Lock】

二、多线程的价值？

1、发挥多核 CPU 的优势

多线程，可以真正发挥出多核 CPU 的优势来，达到充分利用 CPU 的目的，采用多线程的方式去同时完成几件事情而不互相干扰。

2、防止阻塞

从程序运行效率的角度来看，单核 CPU 不但不会发挥出多线程的优势，反而会因 为在单核 CPU 上运行多线程导致线程上下文的切换，而降低程序整体的效率。但 是单核 CPU 我们还是要应用多线程，就是为了防止阻塞。试想，如果单核 CPU 使 用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未 返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。
多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。

3、便于建模

这是另外一个没有这么明显的优点了。假设有一个大的任务 A，单线程编程，那么 就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务 A 分解成几个小任务，任务 B、任务 C、任务 D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

三、创建线程的方法

1、继承Thread类创建线程

继承Thread类，重写run方法。示例代码：

public class MyThread1 extends Thread{//继承Thread类
　　public void run(){
　　//重写run方法
　　}
}
public class Main {
　　public static void main(String[] args){
　　　　new MyThread1().start();//创建并启动线程
　　}
}

优点：编写简单，访问当前线程可以直接用this；
缺点：不能在继承其他类

2、实现Runnable接口创建线程

定义Runnable接口的实现类，一样要重写run()方法。示例代码：

public class MyThread2 implements Runnable {//实现Runnable接口
　　public void run(){
　　//重写run方法
　　}
}
public class Main {
　　public static void main(String[] args){
　　　　//创建并启动线程
　　　　MyThread2 myThread=new MyThread2();
　　　　Thread thread=new Thread(myThread);
　　　　thread().start();
　　}
}

3、使用Callable和Future创建线程

定义Callable接口的实现类，重写call()方法。FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。示例代码：

import java.util.concurrent.Callable; 
import java.util.concurrent.FutureTask; 
  
class MyThread3 implements Callable 
{ 
  //重写call方法，call方法有返回值，run方法返回void
  public Object call() throws Exception 
  {  
  　//重写call方法，并给返回值
    return Thread.currentThread.getName(); 
  } 
} 
  
public class CallableFutureTest 
{ 
  public static void main(String[] args) throws Exception 
  {   
    FutureTask[] tasks = new FutureTask[5]; 
    for (int i = 0; i < 5; i++) 
    { 
      Callable callable = new MyThread3(); 
      tasks [i] = new FutureTask(callable); //使用FutureTask类来包装Callable对象
      Thread t = new Thread(tasks [i]); //FutureTask对象作为Thread类的target
      t.start(); 
    }   
    for (int i = 0; i < 5; i++) 
    { 
      System.out.println(tasks [i].get()); 
      //get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值，经过指定时间没有返回抛出TimeoutException
    } 
  } 
}

控制台打印：

Thread-0
Thread-1
Thread-2
Thread-3
Thread-4

优点：通过Runnable、Callable接口方式，线程类还可以继承其他类；适合多个线程处理同份资源，将cpu、代码、数据分开；
缺点：变成相对复杂，访问当前线程必须使用Thread.currentThread（）方法；
二者区别：Runnable规定的方法使run（），不能抛出异常；而Callable规定的方法使call（），可以抛出异常；Callable执行完任务可以返回值，Runnable不能；

4、使用线程池创建线程

Executors类提供了一系列工厂方法用于创建线程池，四种线程池的创建方式：

• public static ExecutorService newFixedThreadPool(int nThreads)
  创建固定数目线程的线程池。
• public static ExecutorService newCachedThreadPool()
  创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线 程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
• public static ExecutorService newSingleThreadExecutor()
  创建一个单线程化的Executor。
• public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
  创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
  示例代码：

public class ThreadPoolDemo{

public static void main(String[] args) throws InterruptedException, ExecutionException {
	//创建线程池对象
	ExecutorService threadPool = Executors.newFixedThreadPool(2);
	//创建一个Callable接口子类对象
	MyThread4 c1 = new MyThread4 ();
	MyThread4 c2 = new MyThread4 ();
	MyThread4 c3 = new MyThread4 ();
	MyThread4 c4 = new MyThread4 ();
	
	Object o1=threadPool.submit(c1).get();
	Object o2=threadPool.submit(c2).get();
	Object o3=threadPool.submit(c3).get();
	Object o4=threadPool.submit(c4).get();
	System.out.println(o1);
	System.out.println(o2);
	}
}
class MyThread4 implements Callable 
{ 
  public Object call() throws Exception 
  {  
    return Thread.currentThread.getName(); 
  } 
} 

多次执行会发现结果不一定，四个任务，不一定线程池中哪个线程来执行，这是随机的，execute会首先在线程池中选择一个已有空闲线程来执行任务，如果线程池中没有空闲线程，它便会创建一个新的线程来执行任务。控制台打印：

pool-1-thread-1
pool-1-thread-2
pool-1-thread-2
pool-1-thread-1

使用Executor线程池框架的优点：

1）能复用已存在并空闲的线程从而减少线程对象的创建从而减少了消亡线程的开销。
2）可有效控制最大并发线程数，提高系统资源使用率，同时避免过多资源竞争。
3）框架中已经有定时、定期、单线程、并发数控制等功能。

综上所述使用线程池框架Executor能更好的管理线程、提供系统资源使用率。

四、线程池中核心线程数量大小怎么设置

1）CPU密集型任务:比如像加解密，压缩、计算等一系列需要大量耗费 CPU 资源的任务，大部分场景下都是纯 CPU 计算。

对于计算密集型任务，线程数的设置应该尽量与CPU核心数相匹配。这是因为计算密集型任务主要消耗CPU资源，更多的线程并不会带来更高的并发效率，反而可能引起上下文切换，降低性能。

一般：核心线程数 = CPU核心数

2）I/O密集型任务:比如像 MYSQL 数据库、文件的读写、网络通信等任务，这类任务不会特别消耗 CPU 资源，但是I/O操作比较耗时，会占用比较多时间。可以使用稍大的线程池。

I/O密集型任务CPU使用率并不高，因此可以让CPU在等待I/O的时候有其他线程去处理别的任务，充分利用CPU时间。

一般：2*CPU核心数。

设置线程池核心线程数是一个权衡过程，涉及任务类型、系统资源和应用需求。对于计算密集型任务，核心线程数应与CPU核心数相近；对于I/O密集型任务，核心线程数应高于CPU核心数；对于混合型任务，可以根据具体特性进行调整。最终，通过性能测试和调优找到最佳的核心线程数配置。