Java多线程快速基础学习

一、线程与进程的区别：

进程是所有线程的集合，每一个线程是进程中的一条执行路径。

1. 什么是进程？
   进程就是一个应用程序，进程是所有线程的集合。
2. 什么是线程？
   线程是进程的一条执行路径，java中的main方法是主线程，其余继承Thread的线程都称之为子线程，gc是负责监听的守护线程，专门用于垃圾回收，jvm自动实现此机制看不见。
   一个应用程序中肯定会有一个线程就是主线程。
3. 线程的同步和异步：
   单任务执行，运行时间较长，任务顺序执行，谓之同步。
   多任务执行，运行时间短，任务并排运行，谓之异步。
   异步情况下其实是CPU在进行线程间的快速切换，但是眼睛看不出来，看到的效果就是并行同时执行，所以不用纠结CPU在线程间快速切换的问题，因为时间太短，短到可以忽略，异步情况下就理解为多线程在并排同时运行。
   异步操作下的某一个线程抛出异常不会影响其它线程的执行，而同步情况下如果线程抛出异常那之后的线程都不会再执行。
   注意：使用多线程情况下，代码不会从上往下进行执行，会同时并行执行，要分析主线程子线程顺序。

二、为什么要使用多线程？

多线程的好处提高程序的效率。

三、多线程应用场景？

主要能体现到多线程提高程序效率。
举例: 迅雷多线程下载、分批发送短信等。

四、线程的创建方式

1. 继承Thread类，重写run方法

   package chauncy.thread;
   
   class CreateThread extends Thread{
   	/**
   	 * run方法执行 需要线程执行的任务、代码。
   	 */
   	public void run(){
   		for (int i = 0; i < 20; i++) {
   			System.out.println("run() i:"+i);
   		}
   	}
   }
   
   /**
    * @classDesc: 功能描述:(创建多线程 方式1：继承Thread类，重写run方法)
    * @author: ChauncyWang
    * @verssion: v1.0
    */
   public class ThreadDemo02 {
   	public static void main(String[] args) {
   		System.out.println("创建线程开始 main");
   		//1.定义一个类继承自Thread类，重写run方法
   		//2.启动线程
   		CreateThread createThread=new CreateThread();
   		//启动一个线程是调用start方法 不是run方法，调用run方法相当于主线程执行。
   		//注意：使用多线程情况下，代码不会从上往下进行执行，会同时并行执行，要分析主线程子线程顺序。
   		createThread.start();
   		System.out.println("线程已经开始启动 main");
   		for (int i = 0; i < 20; i++) {
   			System.out.println("main() i:"+i);
   		}
   	}
   }
   

2. 实现Runnable接口,重写run方法

   package chauncy.thread;
   
   class CreateRunnable implements Runnable{
   
   	/**
   	 * run方法执行线程需要执行的任务、代码
   	 */
   	@Override
   	public void run() {
   		for (int i = 0; i < 100; i++) {
   			System.out.println("run() i:" + i);
   		}
   	}
   	
   }
   
   /**   
   * @classDesc: 功能描述(创建多线程 方式2：实现Runnable接口，重写run方法)  
   * @author: ChauncyWang
   * @version: 1.0  
   */  
   public class ThreadDemo03 {
   	public static void main(String[] args) {
   		// 定义一个类，实现Runnable接口，重写run方法
   		System.out.println("创建线程开始！main");
   		CreateRunnable createRunnable=new CreateRunnable();
   		Thread thread=new Thread(createRunnable);
   		thread.start();
   		System.out.println("线程已经启动！main");
   		for (int i = 0; i < 100; i++) {
   			System.out.println("main() i:" + i);
   		}
   	}
   }
   

3. 使用匿名内部类方式

   package chauncy.thread;
   
   /**   
   * @classDesc: 功能描述(创建多线程 方式3：使用匿名内部类方式创建多线程)  
   * @author: ChauncyWang
   * @version: 1.0  
   */  
   public class ThreadDemo04 {
   	public static void main(String[] args) {
   		System.out.println("创建线程成功！");
   		//使用匿名内部类方式创建线程
   		new Thread(new Runnable() {
   			
   			@Override
   			public void run() {
   				for (int i = 0; i < 100; i++) {
   					System.out.println("run() i:" + i);
   				}
   			}
   		}).start();
   		System.out.println("创建线程结束！");
   		//thread.start();
   		for (int i = 0; i < 100; i++) {
   			System.out.println("main() i:" + i);
   		}
   	}
   }
   

4. 使用继承Thread类还是使用实现Runnable接口好？
   使用实现实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承。
5. 启动线程是使用调用start方法还是run方法？
   开启线程不是调用run方法，而是start方法，调用run只是使用实例调用方法。

五、获取线程对象以及名称

1. 继承Thread类方式获取对象及名称

   package chauncy.thread;
   
   class DemoThread extends Thread {
   	
   	/**
   	 * 在run方法中不能抛出异常，只能trycatch
   	 */
   	@Override
   	public void run() {
   		for (int i = 0; i < 10; i++) {
   			//sleep 传的毫秒数
   			try {
   				//sleep作用是让当前线程从运行状态变成休眠状态，如果时间到期会到运行状态。
   				//sleep不能释放锁，多线程之间实现同步 wait可以释放锁
   				Thread.sleep(1000);
   				//获取到线程的ID，这个ID是多线程随机分配不重复的主键
   				//不用关心Id是从哪里来的，是JVM底层实现，只需要了解getId是作为多线程区分用
   				//getId使用场景：使用多线程并且需要打日志一定要把getId打印出来进行区分不同的多线程
   			} catch (InterruptedException e) {
   			}
   			//getId和getName方法是从Thread类里来的，只有继承Thread类才能使用该方法。
   			System.out.println("id():"+getId()+"----name:"+getName()+"----i:" + i);
   		}
   	}
   }
   
   /**
    * @classDesc: 功能描述()
    * @author: ChauncyWang
    * @version: 1.0
    */
   public class ThreadDemo05 {
   	public static void main(String[] args) {
   		DemoThread demoThread=new DemoThread();
   		//自定义线程名称
   		demoThread.setName("线程①");
   		demoThread.start();
   		DemoThread demoThread2=new DemoThread();
   		demoThread2.setName("线程二");
   		demoThread2.start();
   	}
   }
   

2. 实现Runnable接口方式获取对象及名称

   package chauncy.thread;
   
   class DemoThread2 implements Runnable {
   	
   	/**
   	 * 在run方法中不能抛出异常，只能trycatch
   	 */
   	@Override
   	public void run() {
   		for (int i = 0; i < 10; i++) {
   			//sleep 传的毫秒数
   			try {
   				//sleep作用是让当前线程从运行状态变成休眠状态，如果时间到期会到运行状态。
   				//sleep不能释放锁，多线程之间实现同步 wait可以释放锁
   				Thread.sleep(1000);
   				//获取到线程的ID，这个ID是多线程随机分配不重复的主键
   				//不用关心Id是从哪里来的，是JVM底层实现，只需要了解getId是作为多线程区分用
   				//getId使用场景：使用多线程并且需要打日志一定要把getId打印出来进行区分不同的多线程
   			} catch (InterruptedException e) {
   			}
   			//getId和getName方法是从Thread类里来的，只有继承Thread类才能使用该方法。
   			//System.out.println("id():"+getId()+"----name:"+getName()+"----i:" + i);
   			//Thread.currentThread()获取到当前线程对象
   			System.out.println("id:"+Thread.currentThread().getId()+"----i:" + i);
   		}
   	}
   }
   
   /**
    * @classDesc: 功能描述()
    * @author: ChauncyWang
    * @version: 1.0
    */
   public class ThreadDemo06 {
   	public static void main(String[] args) {
   		/*DemoThread2 demoThread=new DemoThread2();
   		//自定义线程名称
   		demoThread.setName("线程①");
   		demoThread.start();
   		DemoThread2 demoThread2=new DemoThread2();
   		demoThread2.setName("线程二");
   		demoThread2.start();*/
   		new Thread(new DemoThread2()).start();
   	}
   }
   

六、JavaSE和JavaEE中线程的区别

JavaSE中主线程（程序入口）是main函数，JavaEE中主线程是控制层（springmvc）。
JavaSE中多线程的启动创建通过常规三种方式，JavaEE中多线程都是由线程池进行管理。
线程池的配置依据：根据电脑硬件配置，如：多大内存，多少核数。

七、多线程运行状态

线程从创建、运行到结束总是处于五个状态：新建状态、就绪状态、运行状态、阻塞状态、死亡状态。

1. 新建状态
   当用new操作符创建一个线程时，例如new Thread()，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新建状态时，程序还没有开始运行线程中的代码。
2. 就绪状态
   一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
   处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
3. 运行状态
   当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。
4. 阻塞状态
   线程运行过程中，可能由于各种原因进入阻塞状态:
   1>线程通过调用sleep方法进入睡眠状态；
   2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
   3>线程试图得到一个锁，而该锁正被其他线程持有；
   4>线程在等待某个触发条件；
5. 死亡状态
   有两个原因会导致线程死亡：
   1.run方法正常退出而自然死亡，
   2.一个未捕获的异常终止了run方法而使线程猝死。
   为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false。

总结：Java中对应的线程状态：new Thread() 处于新建状态，Thread.start方法为就绪状态，线程在执行run方法状态就为运行状态，run方法走完了、调用了Thread.stop方法（不建议使用stop方法）线程就到了死亡状态 ，调用Thread.sleep方法就进入了阻塞状态，当阻塞状态过期后会到就绪状态。
以上各种发生状态的情况都是局限列举，还有很多情况未进行考虑。
注意：每开一个线程，都会占用CPU资源。所以多线程的开启数量是根据服务器（电脑）配置：CPU核数。多线程分批跑数据类似于分页，分页的作用是减轻查询量。

八、多线程简单应用(模拟多线程分批发送短信)

1. 创建一个用户的实体类UserEntity.java

   package chauncy.batchsendingsms.entity;
   
   public class UserEntity {
   	
   	private String userId;//用户userId
   	private String userName;//用户名称
   	
   	
   	public UserEntity(String userId, String userName) {
   		super();
   		this.userId = userId;
   		this.userName = userName;
   	}
   	
   	public String getUserId() {
   		return userId;
   	}
   	public void setUserId(String userId) {
   		this.userId = userId;
   	}
   	public String getUserName() {
   		return userName;
   	}
   	public void setUserName(String userName) {
   		this.userName = userName;
   	}
   
   	@Override
   	public String toString() {
   		return "UserEntity [userId=" + userId + ", userName=" + userName + "]";
   	}	
   }
   

2. 创建一个模拟分批发送短信的类BatchThread.java

   package chauncy.batchsendingsms;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import chauncy.batchsendingsms.entity.UserEntity;
   import chauncy.batchsendingsms.util.ListUtils;
   
   class UserThread extends Thread {
   	/**
   	 * 每个线程分批多少数据
   	 */
   	private List<UserEntity> listUser;
   
   	public UserThread(List<UserEntity> listUser) {
   		this.listUser = listUser;
   	}
   
   	@Override
   	public void run() {
   		for (UserEntity userEntity : listUser) {
   			try {
   				Thread.sleep(1000);
   			} catch (InterruptedException e) {
   				e.printStackTrace();
   			}
   			System.out.println("name:" + getName() + userEntity.toString());
   			// 拿到数据之后调用第三方短信接口
   			// 调用短信接口一般不会接收是否发送成功的状态，因为调用短信接口需要转很多接口，需要消耗很多时间，所以在这部分一般会进行一个异步的处理，不需要返回结果。
   			// 但是在发送完成后，过了一些时间会收到哪些成功哪些失败的结果，然后系统可以针对返回结果中失败的采用定时任务跑，进行补发。
   
   		}
   	}
   }
   
   /**
    * @classDesc: 功能描述(多线程分批处理数据)
    * @author: ChauncyWang
    * @version: 1.0
    */
   public class BatchThread {
   	public static void main(String[] args) {
   		// 1.初始化用户
   		List<UserEntity> initUser = initUser();
   		// 2.定义每一个线程最多跑多少数据
   		int userCount = 2;
   		// 3.计算线程数，并且计算每个线程跑哪些数据
   		List<List<UserEntity>> splitList = ListUtils.splitList(initUser, userCount);
   		/**
   		 * 针对于真实的10万用户数据就不能使用List集合了，否则会内存溢出
   		 * 对于这种情况，每次往数据库查询100条，即创建一个大集合，集合里有很多小集合，然后分段进行发送
   		 */
   		for (int i = 1; i <= splitList.size(); i++) {
   			// 拿到的是每个线程跑多少数据
   			List<UserEntity> list = splitList.get(i - 1);
   			// 4.让子线程进行分批异步处理数据
   			UserThread userThread = new UserThread(list);
   			userThread.start();
   			// System.out.println("i:"+i+"----"+list.toString());
   		}
   	}
   
   	/**
   	 * @methodDesc: 功能描述(初始化用戶信息)
   	 * @author: ChauncyWang
   	 * @param: @return
   	 * @returnType: List<UserEntity>
   	 */
   	public static List<UserEntity> initUser() {
   		List<UserEntity> listUser = new ArrayList<UserEntity>();
   		for (int i = 1; i <= 11; i++) {
   			listUser.add(new UserEntity("userId:" + i, "userName:" + i));
   		}
   		return listUser;
   	}
   
   	/**
   	 * 发送短信不需要知道结果，因为很消耗时间，针对于发送失败的部分，可以采用定时任务进行补发。 一般企业发短信流程为：
   	 * 需要发送短信的项目组(例如社交项目组)->消息项目组->第三方网关接口
   	 * 消息项目组存放每天短信成功失败的消息日志，消息日志不会存放在数据库中，一般存放在redis或者mongodb,
   	 * 消息项目组一般会有定时任务去查缓存里哪些是发送失败的，然后把消息进行重新补发。
   	 * 在企业级发送短信，一般都会有消息项目组，一般不会让直接调用第三方接口
   	 */
   }