• Java之线程

    目录

    创建线程

    继承Thread类来创建线程 

    实例 

     创建Thread类对象来创建线程

    实例

     实现Runnable接口来创建线程 

    实例

    Thread类的常用方法

    Thread类的构造方法 

    public Thread()

    public Thread(String name)

    public Thread(Runnable target)

    public Thread(Runnable target,String name)

    Thread类常用的方法  

    getName()获取某个进程的进程名称

    setName()修改某个进程的进程名称

    Thread.currentThread()获取当前线程的对象

    isAlive()确认某个线程是否存活

    getPriority()获取某个线程的优先权

    setPriority()设定某个线程的优先权

    sleep()线程的延时函数

    实例

    线程同步

    同步的机制

    实例（没有使用synchronized关键字锁住共享资源时）

    实例（使用synchronized关键字锁住共享资源时） 

    线程的等待和唤醒

    wait()

    notify()

    notifyAll()

    实例

     

     

    创建线程

    继承Thread类来创建线程 

    class Athread extends Thread {
            public void run(){} 
    }

    public class Text {
            public static void main(String[] args) {
                    new Athread().start();  //启动线程
            }    
    }

     

    实例 

    1. //继承THread类来创建线程
    2. class Athread extends Thread {
    3.  
    4. 	public void run(){  //重写Thread类的run()方法，该方法在调用Thread类的start()方法时自动执行
    5. 		while(true){
    6. 			System.out.println("我是线程A");
    7. 			try {
    8. 				Thread.sleep(1000);  //使用Thread类的静态方法，延时函数将线程A挂起1s
    9. 			} catch (InterruptedException e) {
    10. 				e.printStackTrace();
    11. 			}
    12. 		}
    13. 	}
    14. }
    15.  
    16. class Bthread extends Thread {
    17.  
    18. 	public void run(){
    19. 		while(true){
    20. 			System.out.println("我是线程B");  
    21. 			try {
    22. 				Thread.sleep(1000);  
    23. 			} catch (InterruptedException e) {
    24. 				e.printStackTrace();
    25. 			}
    26. 		}
    27. 	}
    28. }
    29.  
    30. public class Text {
    31. 	public static void main(String[] args) {
    32. 	
    33. 		new Athread().start();  //启动线程A
    34. 		new Bthread().start();  //启动线程B
    35. 	
    36. 	}	
    37. }

     创建Thread类对象来创建线程

    public class Text {
            public static void main(String[] args) {

                    Thread Athread = new Thread() {
                             public void run() {}  
                    };

            Athread.start();  //启动线程A 
            }
    }

    实例

    1. public class Text {
    2. 	public static void main(String[] args) {
    3.  
    4. 		//创建Thread类对象
    5. 		Thread Athread = new Thread() {
    6. 			public void run() {  //重写Thread类的run()方法，该方法在调用Thread类的start()方法时自动执行
    7. 				while(true){
    8. 					System.out.println("我是线程A");
    9. 					try {
    10. 						Thread.sleep(1000);  //使用Thread类的静态方法，延时函数将线程A挂起1s
    11. 					} catch (InterruptedException e) {
    12. 						e.printStackTrace();
    13. 					}
    14. 				}
    15. 			}
    16. 		};
    17.  
    18. 		Thread Bthread = new Thread() {
    19. 			public void run() {
    20. 				while(true){
    21. 					System.out.println("我是线程B");
    22. 					try {
    23. 						Thread.sleep(1000);
    24. 					} catch (InterruptedException e) {
    25. 						e.printStackTrace();
    26. 					}
    27. 				}
    28. 			}
    29. 		};
    30. 		
    31. 		Athread.start();  //启动线程A
    32. 		Bthread.start();  //启动线程B
    33. 		
    34. 	}
    35. }
    36.

     实现Runnable接口来创建线程 

    class AThread implements Runnable {  //实现Runnable接口
            public void run() {}   
    }


    public class Text {
            public static void main(String[] args) {
                    Thread a = new Thread(new AThread());
                     a.start();  //启动线程
            }
    }

    实例

    1. class AThread implements Runnable {
    2. 	
    3. 	public void run() {
    4. 		while(true){
    5. 			System.out.println("我是线程A");
    6. 			try {
    7. 				Thread.sleep(1000);  //使用Thread类的静态方法，延时函数将线程A挂起1s
    8. 			} catch (InterruptedException e) {
    9. 				e.printStackTrace();
    10. 			}
    11. 		} 
    12. 	}
    13. }
    14.  
    15. class BThread implements Runnable {
    16. 	
    17. 	public void run() {
    18. 		while(true){
    19. 			System.out.println("我是线程B");
    20. 			try {
    21. 				Thread.sleep(1000);  //使用Thread类的静态方法，延时函数将线程A挂起1s
    22. 			} catch (InterruptedException e) {
    23. 				e.printStackTrace();
    24. 			}
    25. 		} 
    26. 	}
    27. }
    28.  
    29. public class Text {
    30. 	
    31. 	public static void main(String[] args) {
    32. 	
    33. 		Thread a = new Thread(new AThread());
    34. 		a.start();
    35. 		
    36. 		Thread b = new Thread(new BThread());
    37. 		b.start();
    38. 		
    39. 	}
    40. }
    41.

    Thread类的常用方法

    Thread类的构造方法 

    public Thread()

    创建一个Thread对象

    public Thread(String name)

    创建一个Thread对象，参数name是设定线程对象的名称。

    Thread t1 = new Thread("线程1")  //设定线程对象名称为线程1

    public Thread(Runnable target)

    创建一个Thread对象，参数target是Runnable接口类型的对象，此构造方法将实现Runnable接口的类的对象放在Thread对象中，启动线程时会执行target对象的run()方法。

    class AThread implements Runnable {  //实现Runnable接口
            public void run() {}   
    }


    public class Text {
            public static void main(String[] args) {
                    Thread a = new Thread(new AThread());
                    a.start();  //启动线程
            }
    }

    public Thread(Runnable target,String name)

    创建一个Thread对象，参数name是设定线程对象的名称，参数target是Runnable接口类型的对象。

    Thread类常用的方法  

    getName()获取某个进程的进程名称

    Thread a = new Thread()；

    a.getName();  //获取某个进程的线程名称

    setName()修改某个进程的进程名称

    Thread a = new Thread(String)；

    a.setName();  //修改某个进程的线程名称

    Thread.currentThread()获取当前线程的对象

    Thread a = new Thread()； 
    Thread.currentThread();  //获取当前线程的对象

    isAlive()确认某个线程是否存活

    Thread a = new Thread()； 
    a.isAlive(); //确认线程是否存活，如果存活返回true，如果死亡返回false 

    getPriority()获取某个线程的优先权

    Thread a = new Thread()； 
    a.getPriority();  //获取某个线程的优先权,默认为5 

    setPriority()设定某个线程的优先权

    Thread类的优先权常量：

    • Thread.MIN_PRIORITY：数值为1，最低优先权
    • Thread.NORM_PRIORITY ：数值为5，默认优先权
    • Thread.MAX_PRIORITY：数值为10，最高优先权

    Thread a = new Thread()； 

    a/​​​​​​.setPriority(int);  //设定某个线程的优先权，默认为5，最低为1，最高为10,处于就绪队列中的线程优先权越高，越先被执行

    sleep()线程的延时函数

    Thread a = new Thread()； 
    Thread.sleep(int);  //让线程挂起（延时）一段毫秒时间

    实例

    1. public class Text {
    2. 	
    3. 	static int cnt = 0;
    4. 	
    5. 	static public void inspectThread(Thread obj){  
    6. 		if(obj.isAlive() == true){  //isAlive()确认线程是否存活，如果存活返回true，如果死亡返回false
    7. 			System.out.println("线程还活着");
    8. 		}else if(obj.isAlive() == false){
    9. 			System.out.println("线程已经死了");
    10. 		}else{
    11. 			System.out.println("不知道线程的状态");
    12. 		}
    13. 	}
    14. 	
    15. 	public static void main(String[] args) {
    16. 		
    17. 		Thread a = new Thread("线程1"){
    18. 			public void run() {
    19. 				while(true){
    20. 					System.out.println("jiangxiaoya");
    21. 					cnt += 1;
    22. 					if(cnt == 5){
    23. 						break;
    24. 					}
    25. 					try {
    26. 						Thread.sleep(3000);  //sleep()线程的延时函数：将线程A挂起3s
    27. 					} catch (InterruptedException e) {
    28. 						e.printStackTrace();
    29. 					}
    30. 				}
    31. 			}
    32. 		};
    33. 		System.out.println(a.getName());  //getName()获取某个进程的线程名称
    34. 		a.setName("myThread");  //setName()修改某个进程的线程名称
    35. 		System.out.println(a.getName());  
    36. 		Thread.currentThread().setName("线程1");  //Thread.currentThread()获取当前线程的对象
    37. 		
    38. 		
    39. 		a.start();  
    40. 		inspectThread(a);
    41. 		
    42. 		System.out.println(a.getPriority());  //getPriority()获取某个线程的优先权,默认为5
    43. 		a.setPriority(9);  //setPriority()设定某个线程的优先权，默认为5，最低为1，最高为10,处于就绪队列中的线程优先权越高，越先被执行
    44. 		try{
    45. 			a.join();  //等待线程对象a的线程执行完毕
    46. 		}catch (InterruptedException e) {
    47. 			e.printStackTrace();
    48. 		}
    49. 		inspectThread(a);  
    50. 	}	
    51. }

    2abe25b1a8e94b5cb076747813f78f19.png

    线程同步

    线程同步主要是为了避免同一个时间点有多个线程同时访问同一个共享资源（例如对象）而造成的数据错误。

    同步的机制

    Java的关键字synchronizedH会把程序块锁入一个房间中，房间每次只能允许一个线程进入，线程对象进入房间前会去房间门口领取钥匙。例如A线程是第一个访问这个房间的，那么A线程就直接领取房间门口的钥匙进入房间，后面的线程B和线程C也来到房间门口，但线程B和线程C需要阻塞等待（进入中断状态）线程A从房间出来归还钥匙后才能领取钥匙进入房间。

    实例（没有使用synchronized关键字锁住共享资源时）

    1. class myThread implements Runnable {
    2. 	
    3. 	int grabed;  //已经偷得的金条数量
    4. 	static int totalGold = 200000;  //金条总数
    5. 	Thread t;
    6. 	
    7. 	public myThread(String name) {  //构造方法
    8. 		t = new Thread(this,name);  //this == (t1)new myThread();
    9. 		t.start();  //启动线程
    10. 	}
    11. 	
    12. 	private static boolean grabGold() {  //判断金条是否剩余，如果剩余还能偷取
    13. 		if(totalGold > 0){
    14. 			totalGold--;  //偷取一条金条
    15. 			return true;
    16. 		}else {
    17. 			return false;
    18. 		}
    19. 	}
    20. 	
    21. 	public void run() {
    22. 		while(grabGold()){
    23. 			grabed++;  //获得一条金条
    24. 		} 
    25. 		System.out.println(t.getName() + "总共偷得金条" + grabed +"条");
    26. 	}
    27. }
    28.  
    29. public class Text {
    30. 	
    31. 	public static void main(String[] args) {
    32. 	
    33. 		System.out.println("共有金条" + myThread.totalGold +"条");
    34. 		myThread t1 = new myThread("A");  //创造线程A去偷金条
    35. 		myThread t2 = new myThread("B");  //创造线程B去偷金条
    36. 		myThread t3 = new myThread("C");  //创造线程C去偷金条
    37. 		
    38. 	}
    39. }
    40.

    d3170cdaa1114e20a3e566a23ba1b8f8.png

    实例（使用synchronized关键字锁住共享资源时） 

    1. class myThread implements Runnable {
    2. 	
    3. 	int grabed;  //已经偷得的金条数量
    4. 	static int totalGold = 200000;  //金条总数
    5. 	Thread t;
    6. 	
    7. 	public myThread(String name) {  //构造方法
    8. 		t = new Thread(this,name);  //this == (t1)new myThread();
    9. 		t.start();  //启动线程
    10. 	}
    11. 	//当使用synchronized关键字将金条（共享资源）放进一个房间时，一次只能由一个线程偷取
    12. 	private synchronized static boolean grabGold() {  //判断金条是否剩余，如果剩余还能偷取
    13. 		if(totalGold > 0){
    14. 			totalGold--;  //偷取一条金条
    15. 			return true;
    16. 		}else {
    17. 			return false;
    18. 		}
    19. 	}
    20. 	
    21. 	public void run() {
    22. 		while(grabGold()){
    23. 			grabed++;  //获得一条金条
    24. 		} 
    25. 		System.out.println(t.getName() + "总共偷得金条" + grabed +"条");
    26. 	}
    27. }
    28.  
    29. public class Text {
    30. 	
    31. 	public static void main(String[] args) {
    32. 	
    33. 		System.out.println("共有金条" + myThread.totalGold +"条");
    34. 		myThread t1 = new myThread("A");  //创造线程A去偷金条
    35. 		myThread t2 = new myThread("B");  //创造线程B去偷金条
    36. 		myThread t3 = new myThread("C");  //创造线程C去偷金条
    37. 		
    38. 	}
    39. }
    40.

    44325170564745ffbb6bdcf48aabade2.png

    线程的等待和唤醒

    Object对象中提供wait()、notify()、notifyAll()方法可以让线程间相互设定等待或者唤醒。

    wait()

    让指定的线程进入等待队列成为等待状态。wait()方法必须写在synchronized程序块中，并用try...catch捕获异常。另外，为避免其他线程执行notify()方法或notifyAll()方法时唤醒不能唤醒的线程，所谓wait()方法必须写在while等循环中，并配合满足循环的条件。

    notify()

    唤醒一个在等待队列等待的线程，哪个线程被唤醒则由JVM决定。

    notifyAll()

    唤醒所有在等待队列等待的线程，哪个线程会先执行则由JVM决定。

    实例

     

    1. class Baseball {
    2. 	private boolean isThrow = false;  //棒球初始状态为未投出
    3. 	
    4. 	public synchronized void pBall(int tNo){  //投球机
    5. 		
    6. 		while(isThrow){  //如果已经投球就等待击打者打球
    7. 			try{
    8. 				wait();  //进入等待状态
    9. 			} catch (InterruptedException e){}
    10. 		}
    11. 		//投球
    12. 		System.out.println("投出第 " + tNo + " 颗棒球");
    13. 		isThrow = true;  
    14. 		notify();  //唤醒击打者
    15.  
    16. 	}
    17. 	
    18. 	public synchronized void hBall(int aNo){  //击打
    19. 		while(!isThrow){  //如果已经打球就等待投球机投球
    20. 			try{
    21. 				wait();  //进入等待状态
    22. 			} catch (InterruptedException e){}
    23. 		}
    24. 		//打球
    25. 		System.out.println("第 " + aNo + " 次挥棒");
    26. 		isThrow = false;  
    27. 		notify();  //唤醒投球机
    28. 	}
    29. }
    30.  
    31.  
    32. class Pitching implements Runnable {
    33. 	
    34. 	Baseball  baseball;
    35. 	Pitching(Baseball baseball){
    36. 		this.baseball = baseball;
    37. 	}
    38. 	
    39. 	public void run() {
    40. 		for (int i = 1; i <= 5; i++){  //投5次球
    41. 			baseball.pBall(i);  
    42. 		}	
    43. 	} 
    44. }
    45.  
    46. class Hit implements Runnable {
    47. 	
    48. 	Baseball  baseball;
    49. 	Hit(Baseball baseball){
    50. 		this.baseball = baseball;
    51. 	}
    52. 	
    53. 	public void run() {
    54. 		for (int i = 1; i <= 5; i++){  //打5次球
    55. 			baseball.hBall(i);
    56. 		}	
    57. 	} 
    58. }
    59.  
    60.  
    61. public class Text {
    62. 	
    63. 	public static void main(String[] args) {
    64. 	
    65. 		Baseball baseball = new Baseball();  //
    66. 		
    67. 		Thread A = new Thread(new Pitching(baseball));  //A线程投球
    68. 		Thread B = new Thread(new Hit(baseball));  //B线程打球
    69. 		A.start();
    70. 		B.start();
    71. 		
    72. 	}
    73. }
    74.

    ef0de3c983564c5185bdc5aebe3d06e6.png

     

     

     

  • 相关阅读:
    [stm32]温湿度采集与OLED显示
    信息系统项目管理教程（第4版）：第二章 信息技术及其发展
    通过融合UGV的地图信息和IMU的惯性测量数据，实现对车辆精确位置和运动状态的估计和跟踪研究（Matlab代码实现）
    RocketMQ（五）RocketMQ集群架构
    优秀的项目经理如何寻找到价值贡献点？如何成为价值型项目经理？
    卧槽，2行代码，让接口性能提升10倍
    (02)Cartographer源码无死角解析-(21) MapBuilder→AddTrajectoryBuilder()
    【猿创征文|Unity开发实战】—— 2D项目1 - Ruby‘s Adventure 游戏地图绘制（2-1）
    一个动态规划的简单例题
    使用OpenVINO实现飞桨版PGNet推理程序
  • 原文地址：https://blog.csdn.net/weixin_54076783/article/details/127721682