java基础16

1.线程中常用的方法

        1.static Thread currentThread()得到当前正在运行的线程对象

        2.void start() 启动线程
        3.String getName()返回该线程的名称。
           1.当没有设置线程名称的时候，系统会赋予线程一个默认的名称“Thread-0,Thread-1......”
           2.主线程【主方法的执行线程】的名称默认是“main”
         4.void    setName(String name)设置线程名称

void    setPriority(int newPriority) 更改线程的优先级。
    1.线程的优先级有10个级别，分别使用整数1~10来表示。数字越大优先级越高。
    2.为了方便操作，java将10个级别有规定成3个级别，分别是最低的优先级，中等优先级，最高的优先级，并且将这3个级别封装成了静态常量    static int    MAX_PRIORITY 线程可以具有的最高优先级。10
    static int    MIN_PRIORITY线程可以具有的最低优先级。1
    static int    NORM_PRIORITY分配给线程的默认优先级。5
    int    getPriority() 返回线程的优先级。
    3.设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。优先级越高并不代表就一定会优先执行，只是被优先执行的几率增大，因此不要试图通过控制线程的优先级，来保证某一个线程，总是第一个执行。

    守护线程的相关操作方法
        用户线程----通常情况之下我们所创建的线程都是普通线程，非守护线程，也叫用户线程。
        守护线程----也叫精灵线程,当所有用户线程都执行完毕以后，自动结束运行的线程就是守护线程.[共死]
        1.boolean    isDaemon() 测试该线程是否为守护线程。
        2.void    setDaemon(boolean on) 将该线程标记为守护线程用户线程。
        特征：当所有用户线程都执行完毕以后，无论守护线程能否可以继续运行，都要立刻停止运行。

        static void    sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】

        void    interrupt() 中断线程休眠【暂停】。会进入异常【InterruptedException】。

        void    join(long millis)【强制线程执行】等待该线程终止的时间最长为 millis 毫秒。

2.线程的生命周期

        1、线程的生命周期就是线程从一开始创建，到run方法执行完毕以后的状态变化。[状态之间的切换]
       2、线程的生命周期几种状态【1、新建状态 2、就绪状态 3、运行状态  4.阻塞状态 5.死亡状态】

线程的生命周期描述
    1.新建状态:通过new的方式创建出线程对象，此时线程就进入到创建状态【新建状态】。
               新建状态的线程是不能运行。
              新建状态的线程调用start方法，进入就绪状态

    2.就绪状态:线程具备运行能力，只差操作系统【CPU】分配给他运行时间片【万事具备，只欠时间片】
           得到操作系统【CPU】分配给他运行时间片，此时开始执行run方法，进入运行状态。

    3.运行状态：线程运行run方法。
        回到就绪状态：
        1.操作系统【CPU】分配给他运行时间片使用完毕，回到就绪状态。
        进入阻塞状态
        1.运行状态的线程执行了sleep方法，进入阻塞状态。
        2.运行状态的线程执行了wait方法，进入阻塞状态。
        3.运行状态的线程执行了join方法，进入阻塞状态。
        4.运行状态的线程执行输入/输出动作，进入阻塞状态。
        ......
        进入死亡状态
        1.运行状态的线程run方法执行完毕，进入死亡状态。
        2.运行状态的线程调用stop()/destroy() ，进入死亡状态。
    
    4.阻塞状态:线程暂停运行
        回到运行状态
        阻塞状态中的线程，结束了造成阻塞的原因，此时线程进入就绪状态，得到操作系统【CPU】分配给他运行时间片就可以进入运行状态。
        运行状态进入阻塞状态原因：
        1.运行状态的线程执行了sleep方法，进入阻塞状态，休眠时间结束/interrupt，进入就绪状态
        2.运行状态的线程执行了wait方法，进入阻塞状态，调用notify/notifyAll,进入就绪状态        
        3.运行状态的线程执行了join方法，进入阻塞状态，时间技术/其他线程运行结束,进入就绪状态
        4.运行状态的线程执行输入/输出动作，进入阻塞状态，输入/输出结束，进入就绪状态
        
    5.死亡状态:线程运行结束，释放运行资源。
        死亡状态的线程是不能运行，除非再一次使用strat方法重新启动运行。

3.线程安全

        卖票实例:

package com.wangxing.test6;

public class MyThread1 implements Runnable{
	private  int  piao=5;
	@Override
	public void run() {
		//得到线程名称
		String name=Thread.currentThread().getName();
		//持续买票
		boolean flag=true;
		while(flag){
			//判断有没有可卖的票
			if(piao>0){
				//收钱--找钱--打印票
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(name+",卖出1张票，还剩"+(--piao)+"张");
			}else{
				flag=false;
			}
		}
	}
}

package com.wangxing.test6;

public class Main1 {

	public static void main(String[] args) {
		MyThread1  my=new MyThread1();
		Thread  th1=new Thread(my);
		Thread  th2=new Thread(my);
		Thread  th3=new Thread(my);
		th1.setName("窗口1");
		th2.setName("窗口2");
		th3.setName("窗口3");
		th1.start();
		th2.start();
		th3.start();
	}
}

运行结果:
窗口3,卖出1张票，还剩3张
窗口1,卖出1张票，还剩4张
窗口2,卖出1张票，还剩2张
窗口2,卖出1张票，还剩1张
窗口1,卖出1张票，还剩0张
窗口3,卖出1张票，还剩-1张

分析结果:当窗口1卖最后一张票的时候，在收钱打印票的时候，还没有来得及对票数进行减1之前，线程就切换给了窗口3,窗口3认为还有一张票，窗口3就收钱收钱打印票的时候，还没有来得及对票数进行减1之前，线程有切换给了窗口1，窗口1就对票数进减1，完成以后线程切换给窗口3，窗口3对对票数进行减1此时就得到-1这个值。

经过上面运行程序的分析，我得到的结果是:
当多条线程，同时访问同一个资源的时候，会产生数据不一致的错误情况。

什么是线程同步/线程安全？
    线程同步也叫线程安全，当多条线程，同时访问同一个资源的时候,每一次只能由多条线程中的其中一条访问公共资源，当这一条线程访问公共资源的时候，其他的线程都处于等待状态，不能访问公共资源，当这一条线程访问完了公共资源以后，其他线程中的一条线程才能访问资源，剩下的线程继续等待，等待当前线程访问结束，实现这个过程就是线程同步。【排队访问资源】
    
    线程同步/线程安全的实现方式有几种，分别是什么，有什么区别？
    1.synchronized关键字 【同步代码块/同步方法】
        1.同步代码块
             格式:synchronized(同步对象){

              }

package com.wangxing.threaddemo2;

public class MyRunnable implements Runnable{
    private  int  piao=5;
    @Override
    public void run() {
        //得到当前线程的名称
        String  name=Thread.currentThread().getName();
        boolean  flag=true;
        while(flag){
	    //通过代码块
            synchronized(this){
                //判断有没有可卖的票
                if (piao > 0) { //有票可买
                    //收钱--找钱---打印票
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(name + "卖出1张票，还剩" + (--piao) + "张");
                } else {
                    flag = false;
                }
            }
        }
    }
}

同步代码块虽然可以实现买票的效果，但是它在使用的时候，需要设置一个同步对象，由于我们很多时候都不知道这个同步对象应该是谁，容易写错，造成死锁的情况。正是应为这个缺点，我们很少使用同步代码块来实现线程同步。
2.同步方法
    同步方法的定义格式: 访问限制修饰符  synchronized  方法返回值类型 方法名称(){ }
例如:

//同步方法的定义格式: 访问限制修饰符  synchronized  方法返回值类型 方法名称(){ }
    private synchronized boolean  sellpiao(String name){
        //判断有没有可卖的票
        if (piao > 0) { //有票可买
            //收钱--找钱---打印票
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "卖出1张票，还剩" + (--piao) + "张");
            return  true;
        } else {
            return  false;
        }
    }

2.通过Lock接口
        public interface Lock
        常用的接口方法
        void    lock() 获得锁。 
        void    unlock() 释放锁。
        由于上面的锁方法是Lock接口，我们要使用就得先创建出Lock接口对象，由于Lock是个接口不能new ,我们就得使用它的子类来创建对象。
        Lock接口得子类ReentrantLock

例如:

package com.wangxing.threaddemo2;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyRunnable3 implements Runnable{
    private  int  piao=5;
    private Lock  mylock=new ReentrantLock();
    @Override
    public void run() {
        //得到当前线程的名称
        String  name=Thread.currentThread().getName();
        boolean  flag=true;
        while(flag){
                //设置锁
                mylock.lock();
                //判断有没有可卖的票
                if (piao > 0) { //有票可买
                    //收钱--找钱---打印票
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(name + "卖出1张票，还剩" + (--piao) + "张");
                } else {
                    flag = false;
                }
            //释放锁
            mylock.unlock();
            }
        }
}

******Synchronized关键字与Lock接口的区别？*****
    synchronized：
        1.synchronized关键字
        2.自动锁定资源,不灵活
        3.异常时会自动释放锁
        4.不能中断锁，必须等待线程执行完成释放锁。

    Lock:
        1.Lock接口
        2.手动锁定资源，灵活
        3.异常时不会自动释放锁，所以需要在finally中实现释放锁
        4.可以中断锁

死锁
    线程同步在实现的时候会将线程访问的资源锁住，其他的线程不能访问。
    锁死是因为被访问的资源被全部锁住，无法释放，导致线程无法继续执行。
    锁死的具体表现为线程的相互等待。
        A线程等待B线程释放资源继续执行;B线程等待A线程释放资源继续执行.
    减少不必要的线程同步，释放资源,可以接触死锁。

    
线程同步/线程安全
原因:
    当多条线程，同时访问同一个资源的时候，会产生数据不一致的错误情况。

是什么:
    线程同步也叫线程安全，当多条线程，同时访问同一个资源的时候,每一次只能由多条线程中的其中一条访问公共资源，当这一条线程访问公共资源的时候，其他的线程都处于等待状态，不能访问公共资源，当这一条线程访问完了公共资源以后，其他线程中的一条线程才能访问资源，剩下的线程继续等待，等待当前线程访问结束，实现这个过程就是线程同步。【排队访问资源】

怎么做:
    1.synchronized关键字 【同步代码块/同步方法】
    2.通过Lock接口
后果: 死锁 
后果处理: 减少不必要的线程同步，释放资源