深入理解Java多线程（基础篇）

短命女 2022-02-17 15:59 312阅读 0赞

### 文章目录 ###

*   *  一.线程
     *   *  1.线程和进程
         *  2.多线程的应用场景
         *  2.一个线程的生命周期
     *  二，多线程并行和并发的区别
     *  三，Java程序运行原理和JVM的多线程
     *  四，多线程程序实现的两种方式
     *   *  1.继承Thread
         *  2.实现Runnable
         *  3.两种方式的区别
         *  4.匿名内部类实现线程的两种方式
     *  四，获取多线程的名字和设置名字
     *   *  1.获取名字
         *  2.设置名字
     *  六，获取当前线程的对象
     *  七，休眠线程
     *  八，守护线程
     *  九，加入线程
     *  十，同步代码块
     *   *  1.什么情况下需要同步
         *  2.同步代码块
     *  十 一，同步方法

## 一.线程 ##

### 1.线程和进程 ###

*  进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多  
    个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创  
    建、运行到消亡的过程。
 *  线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程  
    中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

**简而言之**:一个程序运行后至少有一个进程，一个进程中可以包含多个线程

### 2.多线程的应用场景 ###

*  红蜘蛛同时共享屏幕给多个电脑
 *  迅雷开启多条线程一起下载
 *  QQ同时和多个人一起视频
 *  服务器同时处理多个客户端请求  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70]

### 2.一个线程的生命周期 ###

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。  
下图显示了一个线程完整的生命周期。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 1]

## 二，多线程并行和并发的区别 ##

*  并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU) 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
 *  并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 2]  
    内存图解  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 3]

## 三，Java程序运行原理和JVM的多线程 ##

*  A:Java程序运行原理
    
     *  Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
 *  B:JVM的启动是多线程的吗
    
     *  JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

## 四，多线程程序实现的两种方式 ##

### 1.继承Thread ###

*  定义类继承Thread
 *  重写run方法
 *  把新线程要做的事写在run方法中
 *  创建线程对象
 *  start方法开启新线程, 内部会自动执行run方法，单独调用run方法，将会在直接main()主线程中运行  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 4]

public class Demo2_Thread { 
       
       		/** * @param args */
       		public static void main(String[] args) { 
       			MyThread mt = new MyThread();							//4,创建自定义类的对象
       			mt.start();												//5,开启线程
       			
       			for(int i = 0; i < 3000; i++) { 
       				System.out.println("bb");
       			}
       		}
       	
       	}
       	class MyThread extends Thread { 									//1,定义类继承Thread
       		public void run() { 											//2,重写run方法
       			for(int i = 0; i < 3000; i++) { 							//3,将要执行的代码,写在run方法中
       				System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
       			}
       		}
       	}

结果，若干行aaaaaaaaaaaaaaa，若干行bbbbbbbbbbbbbbbbbb,间隔输出

### 2.实现Runnable ###

接口runnable中只有run()方法  
![在这里插入图片描述][20190419195303584.png]

*  定义类实现Runnable接口
 *  实现run方法
 *  把新线程要做的事写在run方法中
 *  创建自定义的Runnable的子类对象
 *  创建Thread对象, 传入Runnable，因为runnable没有start方法  
    ![thread的构造方法][thread]
 *  调用start()开启新线程, 内部会自动调用Runnable的run()方法

public class Demo3_Runnable { 
    				/** * @param args */
    				public static void main(String[] args) { 
    					MyRunnable mr = new MyRunnable();						//4,创建自定义类对象
    				
    					Thread t = new Thread(mr);								//5,将其当作参数传递给Thread的构造函数
    					t.start();												//6,开启线程
    					
    					for(int i = 0; i < 3000; i++) { 
    						System.out.println("bb");
    					}
    				}
    			}
    			
    			class MyRunnable implements Runnable { 							//1,自定义类实现Runnable接口
    				@Override
    				public void run() { 											//2,重写run方法
    					for(int i = 0; i < 3000; i++) { 							//3,将要执行的代码,写在run方法中
    						System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    					}
    				}
    				
    			}

### 3.两种方式的区别 ###

*  查看源码的区别:
    
     *  a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
     *  b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量target记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法。  
        ![在这里插入图片描述][2019041920032257.png]
 *  继承Thread
    
     *  好处是:可以直接使用Thread类中的方法,代码简单
     *  弊端是:如果已经有了父类,就不能用这种方法
 *  实现Runnable接口
    
     *  好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
     *  弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

简单来说：实现Runable接口是继承Thread的一种补充，推荐第一种。

### 4.匿名内部类实现线程的两种方式 ###

*  继承Thread类
    
        new Thread() {													//1,new 类(){}继承这个类
          	public void run() {											//2,重写run方法
          		for(int i = 0; i < 3000; i++) {							//3,将要执行的代码,写在run方法中
          			System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
          		}
          	}
          }.start();
 *  实现Runnable接口
    
        new Thread(new Runnable(){										//1,new 接口(){}实现这个接口
          	public void run() {											//2,重写run方法
          		for(int i = 0; i < 3000; i++) {							//3,将要执行的代码,写在run方法中
          			System.out.println("bb");
          		}
          	}
          }).start();

## 四，获取多线程的名字和设置名字 ##

### 1.获取名字 ###

通过getName()方法获取线程对象的名字  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 5]

### 2.设置名字 ###

通过构造函数可以传入String类型的名字

new Thread("芙蓉姐姐") { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
    					}
    				}
    			}.start();
    			
    			new Thread("凤姐") { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(this.getName() + "....bb");
    					}
    				}
    			}.start();

![在这里插入图片描述][20190419202045353.png]  
通过setName(String)方法可以设置线程对象的名字

Thread t1 = new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
    					}
    				}
    			};
    			
    			Thread t2 = new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(this.getName() + "....bb");
    					}
    				}
    			};
    			t1.setName("芙蓉姐姐");
    			t2.setName("凤姐");
    			
    			t1.start();
    			t2.start();

## 六，获取当前线程的对象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 6]

pubic static void main(String args[]){ 
         Thread.currentThread(), 主线程也可以获取,在main方法中调用，获取主线程对象
    	
    			new Thread(new Runnable() { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(Thread.currentThread().getName() + "...aaaaaaaaaaaaaaaaaaaaa");
    					}
    				}
    			}).start();
    			
    			new Thread(new Runnable() { 
    				public void run() { 
    					for(int i = 0; i < 1000; i++) { 
    						System.out.println(Thread.currentThread().getName() + "...bb");
    					}
    				}
    			}).start();
    			Thread.currentThread().setName("我是主线程");					//获取主函数线程的引用,并改名字
    			System.out.println(Thread.currentThread().getName());		//获取主函数线程的引用,并获取名字
    			}

![在这里插入图片描述][20190419202947856.png]

## 七，休眠线程 ##

![在这里插入图片描述][20190419203213950.png]

*  Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 \* 1000 \* 1000纳秒 1000000000

pubic static void main(String args[]){ 
    			new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 10; i++) { 
    						System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
    						try { 
    							Thread.sleep(10);
    						} catch (InterruptedException e) { 
    							e.printStackTrace();
    						}
    					}
    				}
    			}.start();
    			
    			new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 10; i++) { 
    						System.out.println(getName() + "...bb");
    						try { 
    							Thread.sleep(10);
    						} catch (InterruptedException e) { 
    							e.printStackTrace();
    						}
    					}
    				}
    			}.start();
    			}

![在这里插入图片描述][20190419204103411.png]

## 八，守护线程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 7]

*  setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
    
        public static void main(String args[]){ 
        		Thread t1 = new Thread() { 
        			public void run() { 
        				for(int i = 0; i < 50; i++) { 
        					System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
        					try { 
        						Thread.sleep(10);
        					} catch (InterruptedException e) { 
        						e.printStackTrace();
        					}
        				}
        			}
        		};
        		
        		Thread t2 = new Thread() { 
        			public void run() { 
        				for(int i = 0; i < 5; i++) { 
        					System.out.println(getName() + "...bb");
        					try { 
        						Thread.sleep(10);
        					} catch (InterruptedException e) { 
        						e.printStackTrace();
        					}
        				}
        			}
        		};
        		
        		t1.setDaemon(true);						//将t1设置为守护线程
        		
        		t1.start();
        		t2.start();
        		}

\`\`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 8]  
所有非守护线程结束了,守护线程就会自动关掉.但是这中间会有延迟.

## 九，加入线程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 9]

*  join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
 *  join(int), 可以等待指定的毫秒之后继续

public static void main(String args[]){ 
    			final Thread t1 = new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 50; i++) { 
    						System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
    						try { 
    							Thread.sleep(10);
    						} catch (InterruptedException e) { 
    							e.printStackTrace();
    						}
    					}
    				}
    			};
    			
    			Thread t2 = new Thread() { 
    				public void run() { 
    					for(int i = 0; i < 50; i++) { 
    						if(i == 2) { 
    							try { 
    								//t1.join(); //插队,加入
    								t1.join(30);						//加入,有固定的时间,过了固定时间,继续交替执行
    								Thread.sleep(10);
    							} catch (InterruptedException e) { 
    								
    								e.printStackTrace();
    							}
    						}
    						System.out.println(getName() + "...bb");
    					
    					}
    				}
    			};
    			
    			t1.start();
    			t2.start();
    			}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 10]

## 十，同步代码块 ##

### 1.什么情况下需要同步 ###

*  当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
 *  如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

### 2.同步代码块 ###

*  使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
 *  多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

public class J_Synchronized { 
    
    	/** * @param args * 同步代码块 */
    	public static void main(String[] args) { 
    		final Printer p = new Printer();
    		
    		new Thread() { 
    			public void run() { 
    				while(true) { 
    					p.print1();
    				}
    			}
    		}.start();
    		
    		new Thread() { 
    			public void run() { 
    				while(true) { 
    					p.print2();
    				}
    			}
    		}.start();
    	}
    
    }
    
    class Printer { 
    	Demo d = new Demo();
    	public void print1() { 
    		//synchronized(new Demo()) { //同步代码块,锁机制,锁对象可以是任意的
    		synchronized(d) { 
    			System.out.print("我");
    			System.out.print("爱");
    			System.out.print("大");
    			System.out.print("中");
    			System.out.print("华");
    			System.out.print("\r\n");
    		}
    	}
    	
    	public void print2() { 
    		//synchronized(new Demo()) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象
    		synchronized(d) { 		
    			System.out.print("关");
    			System.out.print("注");
    			System.out.print("点");
    			System.out.print("赞");
    			System.out.print("\r\n");
    		}
    	}
    }
    
    class Demo{ }

同步  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 11]  
不同步  
![在这里插入图片描述][20190419213539667.png]

## 十 一，同步方法 ##

*  使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
    
    **非静态的同步方法的锁对象是神马?**  
    答:非静态的同步方法的锁对象是this
    
    **静态的同步方法的锁对象是什么?**  
    是该类的字节码对象

package com.heima.syn;
    
    public class Demo2_Synchronized { 
    
    	/** * @param args * 同步代码块 */
    	public static void main(String[] args) { 
    		final Printer2 p = new Printer2();
    		
    		new Thread() { 
    			public void run() { 
    				while(true) { 
    					p.print1();
    				}
    			}
    		}.start();
    		
    		new Thread() { 
    			public void run() { 
    				while(true) { 
    					p.print2();
    				}
    			}
    		}.start();
    	}
    
    }
    
    class Printer2 { 
    	Demo d = new Demo();
    	//非静态的同步方法的锁对象是神马?
    	//答:非静态的同步方法的锁对象是this
    	//静态的同步方法的锁对象是什么?
    	//是该类的字节码对象
    	public static synchronized void print1() { 							//同步方法只需要在方法上加synchronized关键字即可
    		System.out.print("我");
    		System.out.print("爱");
    		System.out.print("大");
    		System.out.print("中");
    		System.out.print("华");
    		System.out.print("\r\n");
    	}
    	
    	public static void print2() { 
    		//synchronized(new Demo()) { //锁对象不能用匿名对象,因为匿名对象不是同一个对象
    		synchronized(Printer2.class) { 		
    			System.out.print("关");
    			System.out.print("注");
    			System.out.print("点");
    			System.out.print("赞");
    			System.out.print("\r\n");
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70]: /images/20220217/85a8fece771b4d33ab0761281310bad1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 1]: /images/20220217/39fbec0209b04b5bb714bfe8ad115671.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 2]: /images/20220217/df44226167de4ef5a404293f999cad20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 3]: /images/20220217/35c794bca99c40d490068ef929845095.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 4]: /images/20220217/4fb4ec756463486da5e87d9c248276e1.png
[20190419195303584.png]: /images/20220217/b64c8ae64b35449281f0f019aa6d119b.png
[thread]: /images/20220217/e7531020155d49819e2e87a02a8e707d.png
[2019041920032257.png]: /images/20220217/81b1835bf93b4597994027107d5176d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 5]: /images/20220217/1b7ad373135b4138a5801d4334d97622.png
[20190419202045353.png]: /images/20220217/55f3de2b68a147d784e0a54678419844.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 6]: /images/20220217/e788ed5d5060421eadbe3d0b3b157918.png
[20190419202947856.png]: /images/20220217/cdfcf2a0b7df45b3aa0aaa00d463f605.png
[20190419203213950.png]: /images/20220217/57bc41c43f584d3f8cbcef54c698f282.png
[20190419204103411.png]: /images/20220217/70c578cbec464d329f96c40f55f05536.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 7]: /images/20220217/9bc90240ed474f9c9f38d8f6a6b56dbe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 8]: /images/20220217/3e205c04fe6f48a4ac76ef878c1557d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 9]: /images/20220217/9d835a77df1444a881e0fbef12b069b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 10]: /images/20220217/6bbf5b18e3724f488f19bc05ef0e5446.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 11]: /images/20220217/727e202de6944ed99cc8ef7779baacfc.png
[20190419213539667.png]: /images/20220217/f704378357ba429e9d50d1fa5f181c17.png