Java线程

一、 概念

1.	进程:程序运行的基本单位,动态概念,占用空间,资源分配单位
2.	程序:静态概念
3.	线程:程序执行的最小单位,执行流CPU调度分派的基本单位,
		一个进程中,线程和线程中是可以共享的,线程之间可以相互通信
		多个线程交替占用CPU

二、 进程和线程的区别

1.	根本区别:进程作为资源分配的单位,线程调度和执行的单位
2.	开销:
	每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。
	线程可以看成时轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC)，
	线程切换的开销小。
3.	所处环境:
	进程:在操作系统中能同时运行多个任务(程序)
	线程: 在同一应用程序中有多个顺序流同时执行
4.	分配内存:
	进程:系统在运行的时候会为每个进程分配不同的内存区域
	线程: 除了CPU之外,不会为线程分配内存（线程所使用的资源是它所属的进程的资源),线程组只能共享资源
5.	包含关系:
	进程:没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个线程,则执行过程不是一条线的,
	而是多条线(线程)共同完成的
	线程:是进程的一部分,所有线程又的时候被称为轻量级进程

三、 线程运行

1.	线程之间内存共享,进程之间不共享
2.	线程之间的堆内存和方法区内存共享
3.	线程之间的栈独立,一个线程一个栈,栈之间互不干扰(多线程并发)
4.	使用多线程后,main方法结束只是主线程结束,主栈空了不影响其他线程

四、 多线程并发

A线程 B线程各自执行  各自不影响

五、 单核并发:

1.	单核CPU不能做到真正的多线程并发,但是可以给人一种并发的感觉
2.	当运行一个程序,启动了多个线程,这些线程同时进入cpu队列中,争夺cpu执行权就称之为并发.
3.	多个线程进入cup队列,cpu尽量选取优先级高的线程执行,执行一个时间片,放弃该线程,
4.	该线程又进入队列中,再次进入cup争夺,cpu再次尽量选择优先级高的线程执行,
	在一定时间段,是多个线程交替执行形成并发执行.
6.	数据混乱:多个线程操作同一个资源,如果没有同步(synchronized),那么资源数据会混乱.

六、 实现

1. Thread*

a.	启动线程: start();
	启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后就瞬间结束了
	启动线程自动调用run方法,run在栈分支的底部
	启动start()和直接调用 run():

直接调用run()不能开辟新的栈空间,还是在主栈中执行的方法,是单一线程执行

b.	常用方法:
线程状态Thread.State 

线程可以处于以下状态之一：

NEW	尚未启动的线程处于此状态。
RUNNABLE	在Java虚拟机中执行的线程处于此状态。
BLOCKED	被阻塞等待监视器锁定的线程处于此状态。
WAITING	正在等待另一个线程执行特定动作的线程处于此状态。
IMED_WAITING	正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED	已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。 	

c. 属性:

MAX_PRIORITY   最大
MIN_PRIORITY   最小
NORM_PRIORITY   默认

d. 构造器

Thread()
Thread(String name)
Thread(Runnable  target)
Thread(Runnable  target,String name)

e. 同一个线程创建多个对象

在方法中获取名字:
Thread.currentThread().getName()
在主界面设置获得名字:
c.setName("C");
c.getName();
默认名字:Thread -0  ,  1  ,2….
将当前线程设置成最高级
c.setPriority(Thread.MAX_PRIORITY);

f. 获得当前执行的线程对象

Thread   main=Thread.currentThread();======静态方法
		    //当前线程
	// Thread.currentThread():那个线程执行run方法哪个线程就是当前线程

g. 优先级

System.out.println(main.getPriority());
//最高线程等级
System.out.println(Thread.MAX_PRIORITY);
//最低
System.out.println(Thread.MIN_PRIORITY);
//默认
System.out.println(Thread.NORM_PRIORITY);

2. Runnable*

Runnable(重点):因为java是单继承,多实现,所以如果只有Thread线程实现类就没办再继承其他的类,而提供解决方案,实现Runnable接口

Thread构造器: Thread(Runnable tr)

a.	classA implements Runnable{}
b.	创建一个可运行的对象
classA a=new class();
c.	将可运行的对象封装成一个线程对象
Thread b=new Thread (r)

3. Callable (了解)

a. Runnable Callable区别

Callable线程可以获取线程的返回值(其他线程因为run返回void)
效率比较低,会使main方法受阻塞

b. 实现

第一步:创建未来任务对象 
FutrueTask task =new FutureTask(Callable接口实现类);
(Java.util.concurrent)
//java并发包
//call()相当与run()
Thread t=new Tread(task);
t.start
在main方法中获取执行结果:Object obj=task.get();
//此方法会导致main方法受阻,要等get方法执行结束

七、 生命周期 线程状态*

1. 新建:创建线程对象(new)

2. 就绪:调用start(),进入cpu队列中,具有执行权

3. 运行:cpu正在执行run()方法

重写run方法不能抛出异常,因为父类该方法没有抛出异常,子类不能抛出更多的异常

4. 阻塞:放弃之前占有的CPU时间片,阻塞解除继续回到就绪状态抢夺时间片

sleep休眠:当前线程休眠状态,不会释放资源(拿着cpu休眠),休眠设置时间值,毫秒,静态方法
中断:t.interrupt():这种中断睡眠的方式依靠异常处理,执行catch()
join 插队:当前线程让其他线程进行插队(join),其他线程执行完成,该线程才能进入cpu队列中.  实例方法
yield 礼让:遇到该方法,那么线程就退回到就绪状态,让同级的线程优先运行(让自己权重降低) 静态方法
wait 等待: 当前线程被阻塞并且释放所有资源,等待其他线程唤醒
死亡:run结束
手动结束线程:

a.	classA: boolean a=true;
	     run(){  if(a){}  
	       else{return}=====结束run方法  }
	b.	main:
	class a=new class();
	Thread b=new Thread(a);
	结束:b.a=false

八、 调度(了解)

java采用的是抢占调度模型,优先级越高越容易抢占
与线程调度有关的方法

九、 同步*

1. 当前线程在对数据操作的时候,那么该线程对这个数据进行锁定,只能当前线程操作该数据,其他线程不能对这个数据操作,直到该线程操作完成,其他线程才能对该数据操作.

2. 关键字:synchronized(多线程共享的数据*);{需要排队执行的方法}

3. ()中写什么:

共享的对象 (比如this “abc”(字符串常量池,所有线程都会同步),只要是共享对象就行,是否有关系不影响

4. 线程安全问题的三个条件

a. 多线程并发
b. 有共享的数据
c. 对数据有修改的行为

• java中的三种变量:静态变量 实例变量 局部变量
• 局部变量永远不会出现线程安全问题,因为不会共享,一个栈一个变量
• 静态变量和实例变量分别在方法区和栈中,会存在共享,常量没有线程安全问题

添加的三种方式

a. 同步代码块 synchronized(){}
b. 实例方法上添加synchronized一定锁的是this,整个方法体都需要同步
c. 静态方法上添加:表示类锁,类锁永远只有一把,类锁是保护静态变量的安全
线程安全与非安全

十、 java中任何一个对象都有一把所

十一、 死锁(了解)

synchronized最好不要嵌套使用
public void run(){
	synchronized(o1){
		Thread.sleep(1000)
			synchronized(o2){
			}
		}
	}

十二、 守护线程

• 后台线程:垃圾回收器,系统数据自动备份
• 特点:
  守护线程一般是一个死循环
  所有的用户线程结束,守护线程自动结束
  main方法是一个用户线程
• 将用户线程设置成守护线程:
  在main方法中:
  start()之前: class类名.setDaemon(true);
  代表main方法结束后守护线程自动结束

十三、 定时器

作用:间隔特定的时间,执行特定的程序

• 实现:

sleep(睡眠时间)
java类库中的定时器:java.utill.Timer
Spring框架中的:SpringTask:最常用
 - java.utill.Timer
a.方法: void schedule(TimerTask task,Date firstTime,long period)  :安排的制定任务每隔一段时间执行一次
task:执行的任务  firstTime:第一次执行任务的时间 period:时间间隔
b.TimerTask实现接口:Runnable
c.代码
Timer t=new Timer();  
// new Timer(true):表示以守护线程的方式
//获取格式
SimpleDateFormat sdf =new SimpelDateFormat(“yyyy-MM-dd HH:mm:ss”);
//将字符串转换为时间
Date firstTime =sdf.parse(“2022-03-14 09:30:00”)
t.schedule(task, firstTime,1000*10)
//间隔10s执行一次
编写一个类继承TimerTask :class A extends TimerTask{
public void run(){}
}

十四、 等待唤醒机制(了解)

• wait() notify()是Object方法自带的,不是线程对象的方法
  notifyAll(): 唤醒在X对象上处于等待的所有线程
• wait() notify()方法必须建立在synchronized()基础上
• 作用
  wait():让当前正在X对象上的线程处于等待状态并且释放之前占有的X对象的锁
  notify():让正在X对象上等待的线程唤醒,随机唤醒

十五、 Lock 锁(了解) 和synchronized 区别

4,Lock 锁