08多线程

多线程

进程线程:

**进程:**正在运行的程序

是系统进行资源分配和调用的独立单位

每一个进程都有它自己的内存空间和系统资源

线程:

CPU调度和分派的基本单位;进程中执行运算的最小单位,可完成一个独立的顺序控制流程

**单线程:**一个进程如果只有一条执行路径,则称为单线程

多线程:

概念:

如果一个进程中同时运行了多个线程,用来完成不同的工作,则称之为“多线程”

多个线程交替占用CPU资源,而非真正的并行执行

好处:

  1. 充分利用CPU资源
  2. 简化编程模型
  3. 带来良好的用户体验
主线程:
Thread类
  • java提供 java.lang.Thread 类支持多线程编程

  • 主线程:

    • main()方法即为主线程入口
    • 产生其他子线程的线程
    • 必须最后完成执行,因为它执行各种关闭动作
    public static void main(String args[]){
    	Thread t = Thread.currentThread();
        System.ou.println("当前线程是:"+t.getName());
        t.setName("MyJavaThread");
        System.ou.println("当前线程名是:"+t.getName());     
    }
    
线程的创建和启动:

创建的两种方式:

  • 继承java.lang.Thread类
  • 实现java.lang.Runnable接口

步骤:定义线程----->创建线程对象----->启动线程----->终止线程

▶继承Thread类创建线程
  1. 定义MyThread类继承Thread类
  2. 在MyThread类中重写run()方法,编写线程执行体
  3. 创建线程对象
  4. 调用start()方法启动线程
public class MyThread extends Thread{
    //重写run()方法
	public void run(){
		for(int i=1;i<100;i++){							
        	System.out.println(Thread.currentThread().getName()+":"+i);
		}
    }
}
public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start(); //启动线程(就绪状态)
    
    //static Thread currentThread():返回当前正在执行的线程对象的引用
		//可以知道当前线程:
		System.out.println(Thread.currentThread().getName());   //main
}
  • run()方法是用来封装被线程执行的代码

  • 多个线程交替执行,并不是真正的“并行”

  • 线程每次执行时长由分配的CPU时间长度决定

run()和start()的区别:

​ run():封装线程执行的代码,直接调用,相当于普通方法的调用

​ start():启动线程,然后由JVM调用此线程的run()方法

设置和获取线程名称:

Thread类中设置和获取线程名称方法:

//void setName(String name):将线程的名称更改为等于参数name.要在MyThread类中创建有无参构造方法
//无参构造方法
MyThread my1 =new MyThread();		
MyThread my2 =new MyThread();
		
my1.setName("哇哈哈");
my2.setName("笑嘻嘻");

//有参构造方法 【super继承父类的name方法】
MyThread my1 =new MyThread("哇哈哈");		
MyThread my2 =new MyThread("笑嘻嘻");	

//String getName():返回此线程的名称
▶实现Runnable接口创建线程
  1. 定义MyRunnable类实现Runnable接口
  2. 在MyRunnable类中实现run()方法,编写线程执行体
  3. 创建线程对象,把MyRunnable对象作为构造方法的参数。
  4. 调用start()方法启动线程
public class MyRunnable implements Runnable{
	public void run(){
		for(int i=1;i<100;i++){			
            System.out.println(Thread.currentThread().getName()+":"+i);
		}
    }
}
public static void main(String[] args) {
    MyRunnable myRunnable = new MyRunnable();
    Thread myThread1 = new Thread(myRunnable);	
    Thread myThread2 = new Thread(myRunnable);
     //启动线程
    thread1.start();
    thread2.start();
}
▶实现Callable接口创建线程

首先new 一个我的类实现实例化,然后将我生成的实例对象注册进入到FutureTask类中,然后将FutureTask类的实例注册进入Thread中运行。

最后可以采用FutureTask中的get() 方法获取自定义线程的返回值。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {  //可以用泛型Callable<V>

	@Override
	public String call() throws Exception {
		for(int i = 0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);	
		}		
		return "这是我的返回值";
	}
}
public static void main(String[] args) throws Exception {
		
		MyCallable mc = new MyCallable();
		//线程1
		FutureTask ft1 = new FutureTask(mc);
		Thread thread1 = new Thread(ft1);
		thread1.start();
		//线程2
		FutureTask ft2 = new FutureTask(mc);
		Thread thread2 = new Thread(ft2);
		thread2.start();
    
		Object s = ft2.get();  
		System.out.println(s);
	}
三种方式的比较:

继承Thread类:编写简单,可直接操作线程;适用于单继承

实现Runnable接口:避免单继承局限性;便于共享资源 :把线程和程序的代码、数据有效分离,体现面向对象的设计思想(推荐使用)

实现Callable接口: FutureTask实现了Runnable接口和Future接口 ;call方法可以抛出异常;FutureTask中的get()方法获取自定义线程的返回值.


线程的状态:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UjxZjpu0-1660047360051)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1659491008324.png)]

新建 就绪 sleep阻塞 运行 死亡

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2Wo7XP4-1660047360053)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660015473572.png)]

线程的调度:

线程调度指按照特定机制为多个线程分配CPU的使用权

  • 分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
  • java使用 抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么随机选一个。优先级高的获取的CPU时间相对多些
说 明
void setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象,并执行其他线程
void interrupt()中断线程
boolean isAlive()测试线程是否处于活动状态
线程优先级:
  • 线程优先级由1~10表示,1最低,默认优先级为5
  • 优先级高的线程获得CPU资源的概率较大
public static void main(String[] args) {
    //创建线程对象并指定线程名
    Thread t1 = new Thread(new MyThread(),"线程A");  
    Thread t2 = new Thread(new MyThread(),"线程B");
    t1.setPriority(Thread.MAX_PRIORITY);  //最高级优先级:10
    t2.setPriority(Thread.MIN_PRIORITY);  //最低优先级:1
    									  //默认是5
    //省略代码……	
}

设置和获取优先级的方法:

  1. public final int getPriority():返回此线程的优先级
  2. public final void setPriority(int newPriority):更改此线程的优先级

线程控制----

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XuCOJE32-1660047360054)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660014030697.png)]

线程休眠sleep:
  • 让线程暂时睡眠指定时长,线程进入阻塞状态

  • 睡眠时间过后线程会再进入可运行状态

    public static void sleep(long millis);
    
    • millis为休眠时长,以毫秒为单位
    • 调用sleep()方法需处理InterruptedException异常
public class Wait {
    public static void bySec(long s) {
         for (int i = 0; i < s; i++) {
             System.out.println(i + 1 + "秒");
             try {
				Thread.sleep(1000);   //线程休眠一秒
             } catch (InterruptedException e) {
				e.printStackTrace();
             }
         }
    }
}
线程的强制运行join:

强制执行当前线程,join写在哪个线程,就阻塞谁

public final void join()
public final void join(long mills)
public final void join(long mills,int nanos)

示例:

public static void main(String[] args) {
      Thread temp = new Thread(new MyThread());
      temp.start();
    
      for(int i=0;i<20;i++){
          if(i==5){				
              try {
                  temp.join();   //阻塞主线程,子线程强制执行
              } catch (InterruptedException e) {
                  e.printStackTrace(); 
              }
          }			
     System.out.println(Thread.currentThread().getName()+"运行:"+i);
     } 
      //省略代码…
}

线程的礼让yield:
  • 暂停当前线程,允许其他具有相同优先级的线程获得运行机会

  • 该线程处于就绪状态,不转为阻塞状态

    public static void yield()
    

    只是提供一种可能,但是不能保证一定会实现礼让

public class MyThread implements Runnable{
     public void run(){
         for(int i=0;i<5;i++){
             System.out.println(Thread.currentThread().getName()+"正在运行:"+i);
             if(i==3){
                 System.out.print("线程礼让:");
                 Thread.yield();	 
             } 
         } 
     }
}

join()方法和yield()方法的区别是:

同步方法:

  • 使用synchronized修饰的方法控制对类成员变量的访问
  • synchronized就是为当前的线程声明一把锁
访问修饰符 synchronized 返回类型 方法名(参数列表){……}

synchronized 访问修饰符 返回类型 方法名(参数列表){……}
同步代码块:
  • 使用synchronized关键字修饰的代码块

    synchronized(syncObject任意对象就是一把锁){
        //需要同步的代码
    }
    
    • syncObject为需同步的对象,通常用this

    • 效果与同步方法相同

      public void run() {
          while (true) {
              synchronized (this) {   //同步代码块
              // 省略修改数据的代码......
             	// 省略显示信息的代码......
      		}
          }
      }
      

代码解析:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBN9yMJ4-1660047360055)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660022546695.png)]

  • 好处:解决了多线程的数据安全
  • 弊端:当线程很多时:因为每个线程会去判断同步上的锁,耗费资源,降低了程序的运行效率
多个并发线程访问同一资源的同步代码块时:
  • 同一时刻只能有一个线程进入synchronized(this)同步代码块
  • 当一个线程访问一个synchronized(this)同步代码块时,其他synchronized(this)同步代码块同样被锁定
  • 当一个线程访问一个synchronized(this)同步代码块时,其他线程可以访问该资源的非synchronized(this)同步代码

线程安全的类型:

one:

ArrayList为非线程安全的类型

  • 查看ArrayList类的add()方法定义

    public boolean add(E e) {
          ensureCapacityInternal(size + 1);  //集合扩容 ,确保能新增数据
          elementData[size++] = e; //在新增位置存放数据
          return true;
    }
    
  • ArrayList类的add()方法为非同步方法

  • 当多个线程向同一个ArrayList对象添加数据时,可能出现数据不一致问题

方法是否同步效率比较适合场景
线程安全多线程并发共享资源
非线程安全单线程
常见类型对比:

Hashtable && HashMap

  • Hashtable

    • 继承关系
      • 实现了Map接口,Hashtable继承Dictionary类
    • 线程安全,效率较低
    • 键和值都不允许为null
  • HashMap

    • 继承关系
      • 实现了Map接口,继承AbstractMap类
    • 非线程安全,效率较高
    • 键和值都允许为null

StringBuffer&& StringBuilder

  • 前者线程安全,后者非线程安全

------------- | ------------ | ---------------------- |
| 线程安全 | | | 多线程并发共享资源 |
| 非线程安全 | | | 单线程 |

常见类型对比:

Hashtable && HashMap

  • Hashtable

    • 继承关系
      • 实现了Map接口,Hashtable继承Dictionary类
    • 线程安全,效率较低
    • 键和值都不允许为null
  • HashMap

    • 继承关系
      • 实现了Map接口,继承AbstractMap类
    • 非线程安全,效率较高
    • 键和值都允许为null

StringBuffer&& StringBuilder

  • 前者线程安全,后者非线程安全
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

朱尔斯Jules

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值