• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

java多线程–【Foam番茄】

开发技术 开发技术 2个月前 (11-28) 14次浏览

进程

是系统资源分配的单位

线程

通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是cpu调度和执行的单位

注意:很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错觉
  • 线程就是独立的执行路径
  • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程
  • main()称之为主线程,为系统的入口,用于执行整个程序
  • 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统密切相关的,先后顺序是不能人为的干预的
  • 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
  • 线程会带来额外的开销,如cpu调度时间,并发控制开销
  • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

线程创建

三种创建方式

Thread class ==》》继承Thread类(重点)

Runnable接口 ==》》实现Runnable接口(重点)

Callable接口 ==》》实现Callable接口(了解)

Thread

  • 自定义线程类继承Thread类
  • 重写run()方法,编写线程执行体
  • 创建线程对象,调用start()方法启动线程

总结:注意,线程开启不一定立即执行,由cpu调度执行

Callable

  • 可以定义返回值
  • 可以抛出异常

Runnable

  • 定义MyRunnable类实现Runnable接口
  • 实现run() 方法,编写线程执行体
  • 创建线程对象,调用start() 方法启动线程

推荐使用Runnable对象,因为java单继承的局限性

小结

继承Thread类

  • 子类继承Thread类具备多线程能力
  • 启动线程:子类对象.start()
  • 不建议使用:避免oop单继承局限性

实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程:传入目标对象+Thread对象.start()
  • 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用

实现Callable接口(了解即可)

  • 实现Callable接口,需要返回值类型
  • 重写call方法,需要抛出异常
  • 创建目标对象
  • 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1)
  • 提交执行:Futureresult1=ser.submit(t1)
  • 获取结果:boolean r1=result1.get();
  • 关闭服务:ser.shutdownNow()

静态代理

真实对象和代理对象都要实现同一个接口

代理对象要代理真实角色

好处

代理对象可以做很多真实对象做不了的事情

真实对象专注做自己的事情

Lamda表达式

  • λ希腊字母表中排序第十一位的字母,英语名称为Lambda
  • 避免匿名内部类定义过多
  • 其实质属于函数式编程的概念

为什么要使用lambda表达式

  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码,只留下核心的逻辑

也许你会说,我看了Lambda表达式,不但不觉得简洁,反而觉得更乱,看不懂了。那是因为我们还没有习惯,用的多了,看习惯了,就好了

理解Functional Interface (函数式接口)是学习java8 lambda表达式的关键所在

函数式接口的定义:

	任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口
public interface Runnable{
	public abstract void run();
}
	对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
		// 1.lambda表达式简化
		ILove love =(int a)->{
				System.out.println("I love you-->"+a);
		};
		
		// 2.简化参数类型
		ILove love=(a)->{
			System.out.println("I love you-->"+a);
		};
		
		// 3.简化括号
		ILove love=a->{
			System.out.println("I love you-->"+a);
		};
		
		// 3.去掉花括号
		ILove love=(a,b)->
		System.out.println("I love you-->"+a+b);
		
		// 总结:lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹
		// 前提是接口为函数式接口
		// 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号

线程状态

java多线程--【Foam番茄】
java多线程--【Foam番茄】

线程休眠

  • sleep(时间)指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException;
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延迟,倒计时等
  • 每一个对象都有一个锁,sleep不会释放锁

线程礼让

  • 礼让线程,让当前正在执行的线程暂停,但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度,礼让不一定成功!看cpu心情

Join

  • join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
  • 可以想象成插队

守护线程(daemon)

  • 线程分为用户线程守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如,后台记录操作日志,监控内存,垃圾回收等待……

线程同步

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题:

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。

多个线程操作同一个资源

线程同步其实就是一种等待机制,多个需要同时访问此对象得线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用

同步方法

  • 由于我们可以用过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块

    同步方法:public synchronized void method(int args){}
    
  • synchronized方法控制对象的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行

    缺陷:若将一个大的方法申明为synchronized将会影响效率
    

    锁的对象就是变化的量,需要增删改的对象

同步方法弊端

  • 方法里面需要修改的内容才需要锁,锁的太多,浪费资源

同步块

  • 同步块:synchronized(Obj){}
  • Obj称之为同步监视器
    • Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class
  • 同步监视器的执行过程
    • 第一个线程访问,锁定同步监视器,执行其中代码
    • 第二个线程访问,发现同步监视器被锁定,无法访问
    • 第一个线程访问完毕,解锁同步监视器
    • 第二个线程访问,发现同步监视器没有锁,然后锁定并访问

死锁

  • 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情节,某一个同步块同时拥有“两个以上对象的锁”是,就可能会发生“死锁”的问题

死锁避免方法

产生死锁的四个必要条件

  • 互斥条件:一个资源每次只能被一个进程使用
  • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
  • 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

synchronized与Lock的对比

  • Lock是显示锁(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放

  • Lock只有代码块锁,synchronization有代码块锁和方法锁

  • 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)

  • 优先使用顺序

    Lock》同步代码块(已经进入了方法体,分配了相应资源)》同步方法(在方法体之外)

    // 定义lock锁   可重用锁
    private final ReentrantLock lock=new ReentrantLock();
    

线程协作

使用线程池

  • 背景:经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大
  • 思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。类似生活中的公共交通工具
  • 好处:
    • 提高响应速度(减少了创建新线程的时间)
    • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
    • 便于线程管理
      • corePoolSize:核心池的大小
      • maximumPoolSize:最大线程数
      • keepAliveTime:线程没有任务时最多保持多长时间后会终止
      • newFixedThreadPool 参数位:线程池大小

喜欢 (0)