线程###

什么是线程

作用:让多个任务同时进行

本质:一个线程就是一个执行路径

名词介绍

主线程:当一个程序开启时自带一个线程,该线程就是主线程,主线程名称:main

子线程:程序员在程序中自己创建的线程都是子线程

进程:一个正在进行的程序,一个进程中可能会有多个线程.一个进程如果一个线程都没有,那么该进程将会被系统回收

多线程:一个进程中有多个线程

守护线程:又名后台线程,特点:当程序中的所有前台线程执行完毕后,此时不管是否有守护线程存活,进程都将被系统回收

前台线程:默认创建的线程与主线程都是前台线程,当一个进程中有前台线程存活,那么进程将不会被系统回收

线程的组成

CPU时间片:线程获取 到CPU执行权后,可执行的时间

线程理解:
    宏观:多个线程同时执行
    微观:多个线程交替执行

执行逻辑

内存:一个线程对应一个栈内存,多个线程共享一个堆内存

线程的状态

新建状态
        尚未启动的线程处于此状态。不会抢夺CPU执行权 

就绪状态
        线程后,但是没有获取到CPU执行权

运行状态
        线程获取到CPU执行权后

休眠状态
        线程停止,如调用sleep,join等
            有限期休眠
            无限期休眠

消亡状态
        线程执行完run方法中的代码,等待被系统回收

线程得使用

创建:

通过继承Thread或者是实现Runnable接口

Thread:

    //1,创建一个类继承与Thread
	//2,重写run方法
	//3,创建该类对象

class 类名 extends Thread{
	
    @overide
	
    public void run(){
    
    }
}

    //匿名内部类
	
	Thread thread = new Thread(){
         @Override
        
         public  void run(){ }
     };

     thread.start();

Runnable:

    //1,创建一个类现实Runnable接口
	//2,重写run方法
	//3,创建该类对象(线程任务对象)
	//4,创建线程对象(Thread的对象)并传入线程任务对象
	
	class 类名 implements Runnable{
	
    @Override

	public void run(){ }

	}
	
    new Thread(new 类名()).start();

	//使用匿名内部类创建Runnable的子类对象
	
	Runnable 名=new Runnable(){
	
    @Override
	public void run(){  
    }
	
   };
 
new Thread(名).start();

 

注意 :

Runnable接口比继承Thread类更灵活，因为Java只支持单继承，如果已经有一个基类需要继承，就无法再继承Thread类了。而实现Runnable接口可以在有需要时灵活地提供自己的线程任务。

使用:

线程的启动:线程对象.start();

提问:

直接调用run方法与使用线程对象.start方法的区别?
    start方法会开启新的执行路径,而run不会

    一个线程只能启动一次

线程的消亡

线程已经启动不受控制,当run方法中的代码执行完毕,将等待系统回收

线程的名称

设置名称

                方式1:创建线程对象时设置
                            Thread(Runnable run,String name)
                方式2:setName方法
                            线程对象.setName("线程名称");
            注意:在线程启动前设置

获取名称

String getName();

获取当前线程

 public static native Thread currentThread();

线程的优先级

作用:提高线程获取到CPU执行权的概率

方法

public final void setPriority(int newPriority) 

注意:优先级取值范围1-10,默认为5

线程的礼让

作用:释放已经获取到的CPU执行权,然后重新参与抢夺

语法:public static native void yield();

线程的合并

作用:让多个线程合并后进行

语法

public final void join()

守护线程

特点:当程序中的所有前台线程执行完毕后,此时不管是否有守护线程存活,进程都将被系统回收

public final void setDaemon(boolean on)
当值为true表示为守护线程

线程的休眠

作用:让当前线程沉睡,线程在该情况下不会抢夺CPU执行权

public static native void sleep(long millis)

线程安全

原因:多个线程同时操作一个数据导致的

思路:保证同时只能有一个线程操作数据

方法:同步

方式1:同步代码块
	语法:
		synchronized(锁对象){
			要同步的代码
		}
	
方式2:同步方法
	语法:
		访问权限修饰符 synchronized 返回值类型 方法名(形参列表){
			方法体
		}
	注意:
		同步方法的锁对象是调用该方法的对象
		
方式3:同步静态方法
	语法:
		访问权限修饰符 synchronized static 返回值类型 方法名(形参列表){
			方法体
		}
	注意:
		同步静态方法的锁对象,是该方法所在的类的类对象
	类对象:
		当系统加载类时会生成一个类对象,该对象包含该类的所有信息,如该类的包名,类名,父类名,父接口名,方法名,属性名等....
		因为一个类只会被加载一次,所以一个类只有一个类对象
		
		class A{
		
		}
		A a = new A();//类的对象

注意:
	多个线程的锁对象是同一个
	锁对象:任意一个类的对象都可以

死锁

原因:多个线程互相持有对方所需的锁资源

避免:不要在同步中使用同步

线程间通讯

作用:让当前线程休眠,或唤醒其他线程

提供的方法

wait():让当线程休眠,直到被唤醒
wait(long ms),让当线程休眠,休眠时间ms,单位毫秒
wait(long ms,int ns)让当线程休眠,休眠时间ms+ns,ms单位毫秒,ns单位纳秒

notify():随机唤醒该进程中以调用该方法的对象作为锁对象的一个线程
notifyAll:唤醒该进程中以调用该方法的对象作为锁对象的所有线程

注意事项:

1,由Object提供
2,必须在同步中使用
3,必须使用所在的同步的锁对象调用 

wait:
    在休眠时会释放所持有的锁对象
    由Object提供
    只能在同步中,使用该同步的锁对象调用
sleep:
    在休眠时不会释放所持有的锁对象
    有Thread类提供的静态方法
    在任何一处都可使用