JAVA_learning 28多线程_28.多线程-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_34774226/article/details/109125398

本文介绍Java多线程的基础概念，包括进程、线程的区别及线程的创建与使用方法，并探讨了线程同步、死锁及通信等问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

高级部分

多线程
JAVA常用类
枚举类，注解
Java集合
泛型
I/O流
网络编程
Java反射机制
新特性

多线程

区别程序，进程，线程
1. 程序——一段静态的代码
2. 进程——正在运行的一个程序，因此它会有开始，结束，生命周期这样的定义，所以说进程是一个动态的过程。
3. 线程——可视为一个程序内部的一条执行路径，一个进程中，可能同时运行多个线程
每个进程都拥有自己独立的：栈，程序计数器
多个线程，共享同一个进程中的结构：方法区，堆——这个交互的过程称为通讯，也是由于通讯的存在，多个线程操作共享的资源时可能带来安全隐患。因此引出下面的线程的同步
```
 5. 一个java应用程序至少有三个线程，main()主线程，gc()垃圾回收线程，异常处理线程
 6. 并行：多个CPU同时执行多个任务
 7. 并发： 一个CPU执行多个任务 ——秒杀，多个人做一件事
```
线程的创建与使用
1. 创建方式1：
1. 1.继承于Thread类的子类
2. 重写Thread类中的run()方法——此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()
```
 package com;
 public class atgui {
 	 //main()方法——主线程
 	public static void main(String args[]){

 	   //通过Thread类的子类创建对象
		 MyThread myThread = new MyThread();
		 //使用该对象调用start()，开启分线程
 	   myThread.start();
	 //主线程继续运行
 //从结果上看好像主线程先行，然后才是分线程，但这可能是由于主线程运行的时间太短
	 //System.out.println("java");
 	  //采用同样的运行内容
 	  //每次的结果都不相同，这表明进程之间并没有先后之分，
 	  for (int i = 0; i < 100; i++) {
 		    if (i % 2 == 0) {
     		    System.out.println(i + "*******");
   		  }
 	  }
  }

 }
 class MyThread extends Thread{
    //重写run()方法
     public void run() {
 	  for (int i = 0; i < 100; i++) {
   		  if(i%2==0){
     		    System.out.println(i);
   		  }
 	  }	
  }
 }		
```
1. start()方法的作用：
  1. 启动当前线程(继承于Thread的线程)
  2. 自动调用当前线程的run()方法——但run()方法已经重写了，所以就会调用重写后的run()方法，而该方法中就是我们需要分线程做的事
2. 既然start()方法还是会调用run()方法，那为什么不直接用run()方法——这就涉及到start()方法能创建线程了，如果我们用run()代替start()，尽管不会报错，但是这再也不是多线程了，运行结果是固定的。
3. 创建方式2：实现RUnnable接口
  1. 创建一个实现Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()
4. 开发中优先选择实现Runnable接口的方式，原因：
  1. 采用实现Runnable接口的方式，没有类的单继承性的局限
  2. 实现的方式更适合来处理多个线程数据共享的情况
5. 两种实现方式的联系——其实thread类也实现了Runnable接口，也就是说方式1，就是继承实现了Runnable的Thread，方式2就是直接实现Runnable，
  因此二者的相同点就是都必须重写run()方法
Thread常见方法
1. getName()，setName()
2. currentThread()，静态方法，返回执行当前代码的进程
例如，修改main()方法所在主线程的名字，Thread.currentThread.getName()
3. yield()——静态方法，释放当前cpu的执行权，让其他线程去获取。但这个过程是不固定的，也就是说可能刚放弃PUC的执行权，CPU立刻又分配给该进程。如果某个一个线程是一个不太重要的线程，我们就会在它里面调用yield()方法，让其他线程获得更多的执行机会
4. join()——在单核CPU中，如果线程a调用线程b的join()方法，那么线程a进入阻塞状态，一直都不会执行，直到进程b执行完毕，线程a才结束阻塞状态
5. sleep(long millitime)——定时阻塞，会返回一个Interrupted Exception，所以必须使用try catch(为什么不能使用throws，因为使用throws必须使run()方法继承某个Exception，但是run()方法是重写后的，而重写前的run()方法不会抛出异常，根据重写的规则，子类抛的异常类型不大于父类，所以不能使用throws)。
6. isAlive()——判断当前进程是否存活
线程的调度——线程的优先级
线程的生命周期
1. 新建 Thread a=new Thread();
2. 就绪——调用start()，
3. 运行——获取CPU执行权
4. 阻塞
5. 死亡

线程的同步

 1. 正如上面说到的，当一个线程正在操作某个共享变量时，其他线程可能会参与进来，这就可能导致安全问题
 2. 如何解决——设定，当一个线程a在操作某个变量时，其它线程不能参与进来，直到线程a操作完成，在这种情况下，即使线程a出现阻塞，也不可改变
 3. 在java中，我们通过同步机制来解决线程问题
 4. 方法1：同步代码块
 		
 		1. 	
 				synchronized(同步监视器){
 				//需要被同步的代码——操作共享数据的代码
 				}
 		2. 
 		3. 需要被同步的代码——操作共享数据的代码
 		4. 同步监视器：俗称，锁，任何一个对象都可以
 				1. 锁的要求——多个线程共用一把锁
 				2. 在面对implement Runnable的类时，由于类中的数据把本来就是共享的，所以锁的定义很随意。但当extends Thread时，要注意一定要声明为static的。
 				3. 在implement Runnable接口的创建多线程的方式中，我们可以考虑使用this充当锁；但extends Thread类的创建多线程的方式中，慎用this充当锁，但可以考虑使用当前类来充当锁。
 		5. 同步代码块的缺点：使用同步代码块执行程序，效率低下。因为只能有一个线程参与，其他线程等待，相当于单线程。
 5. 方法2： 同步方法
 		1. 同步方法，仍涉及同步监视器，只是是不需要显式的声明
 		2. 非静态的同步方法，同步监视器是this
 		3. 静态的同步方法，同步监视器是当前类本身
 		4. 将懒汉式改为线程安全的
 		
 			class Bank{
 		    private Bank(){};
 		    private static Bank instance = null;
 		    public static synchronized Bank getInstance(){
 		/*        if(instance == null){
 		            instance =new Bank();
 		        }
 		        return instance;*/
 		        //方式1
 		//       synchronized (Bank.class){
 		//        if(instance == null){
 		//            instance =new Bank();
 		//        }
 		//        return instance;
 		//         }
 		        //方式2
 		        if(instance == null){
 		            synchronized (Bank.class){
 		                instance =new Bank();
 		            }
 		         }
 		        return instance;
 		    }