多线程，线程的实现，线程常用方法，同步

程序和进程

程序就是一堆静态的代码，存储在硬盘上。程序如果不运行，本质就是一个文件。

程序一次运行产生进程，进程一直向前运行，直到进程结束。

操作系统的发展

单任务操作系统:一段时间只能运行一个程序(任务)。CPU利用率非常低。

|

|/

引入进程的概念

把程序的一次运行产生进程(内存空间、资源、程序的执行堆栈)

进程作为操作系统分配资源的基本单位。

|

|/

多任务操作系统

一台电脑就一个CPU，多个任务轮流使用CPU，从宏观上看，一段时间有多个任务正在运行。

从微观上看，一个时间点只有一个任务在运行。

CPU时间片

多个进程通过CPU时间片轮转实现多任务(进程)。把这种现象叫做并发操作

并行:

一个时间段，多个任务同时进行，多个CPU运行各自的进行。

|

|/

线程的引入：一个进程里面有一个或多个线程，线程在进程里通过CPU时间片来运行

解决实时性问题

 

package sc.thread;
//多线程实现
//Thread 类位于java.lang中，表示进程中的执行线程。实现多线程有两种方式
//第一种是继承Thread类
//继承Thread的线程类不能再继承其他类，实现Runnable接口的类还可以继承其他类。
public class Thread01 extends Thread{
    //5张票
   private  int count=5;
   


public Thread01(String name) {
        super(name);
    }



public Thread01() {
    super();
}



public void run() {
    // 模拟一个窗口5个人
    for (int i = 0; i <5; i++) {
        if (count>0){
            count--;
            System.out.println(super.getName()+"卖出一张票，还剩" + count + "张票");
        }//本类继承于Thread类；Thread类本身就有个属性是名字，所以在实现进程时可以赋个name给Thread类；否则系统有默认名
    }
}
}

package sc.thread;
//第二种为实现Runnable接口
//实现Runnable接口的线程类，可以让多个线程共享线程实现类的资源
public class Runnable01 implements Runnable{
     private  int count=5;
    

    public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i <5; i++) {
            if (count>0){
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }//本类没有继承于Thread类；所以用Thread.currentThread()（引用本线程的属性）来引用属性，所以在实现进程时可以赋个name给Thread类；否则系统有默认名
        }
        
    }

}

package sc.thread;

public class Test01 {
// main开始运行产生一个进程，该进程默认有个主(main)线程，也就是说main是一个主线程
//多线程的运行其实就是多个线程通过cpu时间轮来抢占 cpu使用，哪个线程抢占到cpu就哪个线程运行，没有规律，
public static void main(String[] args) {
    /*
     * 
    //1.继承Thread类创建线程(Thread类本质也实现Runnable接口)
    Thread01 t1=new Thread01();
    //启动线程
    t1.start();
    
    //2.实现Runnable接口创建线程
    Runnable01 r1=new Runnable01();
    Thread t2=new Thread(r1);
    t2.start();
    
    */
    
    //————————需求：如果总共有5张票，通过三个窗口卖出去
    //第一种方法
    Thread01 t1=new Thread01("1窗口");
    t1.start();
    Thread01 t2=new Thread01("2窗口");
    t2.start();
    Thread01 t3=new Thread01("3窗口");
    t3.start();
    //根据下面结果得到结论：继承Thread类 不适用于需要资源共享时
    /*输出结果：（每个窗口都卖出了5张票）
 2窗口卖出一张票，还剩4张票
2窗口卖出一张票，还剩3张票
2窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩4张票
1窗口卖出一张票，还剩3张票
1窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩1张票
3窗口卖出一张票，还剩4张票
3窗口卖出一张票，还剩3张票
3窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩0张票
2窗口卖出一张票，还剩1张票
3窗口卖出一张票，还剩1张票
1窗口卖出一张票，还剩4张票
2窗口卖出一张票，还剩0张票
     * */
    Runnable01 r1=new Runnable01();
    Thread t4=new Thread(r1,"1窗口");
    t4.start();
    Thread t5=new Thread(r1,"2窗口");
    t5.start();
    Thread t6=new Thread(r1,"3窗口");
    t6.start();
    //根据下面结果得到结论：实现Runnable类适用于需要资源共享时，但是还有瑕疵，它们的数据管理非常乱，为什么了？
    //得到结论：多线程的运行其实就是多个线程通过cpu时间轮来抢占 cpu使用，哪个线程抢占到cpu就哪个线程运行，而且还没等这个线程运行完，运行到一半时，就被另一个线程抢占了cpu，没有规律的抢占，
    //所以为了解决这个问题，就有了(下面)
/*输出结果：（3个窗口总共卖出了5张票）
3窗口卖出一张票，还剩1张票
2窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩3张票
3窗口卖出一张票，还剩0张票
3窗口卖出一张票，还剩0张票
     * */
/*总结:
 多线程提高了cpu利用率，但程序的复杂度也随之增加。
一旦线程开始执行，很难通过其他方式控制线程的轨迹。
多个线程抢占CPU导致线程的运行轨迹不确定。
 多线程抢占CPU执行，可能在任意位置被切换出去(挂起)。
多线程抢占到CPU后，从上次挂起的位置开始执行(先恢复上次的执行堆栈)。
多线程都可以独立运行，相互不干扰，多个线程都可以能访问共享资源，很容易导致数据错乱！！！
*/    
    

 线程的生命周期

新生状态

用new关键字建立一个线程后，该线程对象就处于新生状态。

处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。

就绪状态

处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。

当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。

运行状态

在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。

如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

阻塞状态

处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。

在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。

死亡状态

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行

的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个

线程【不推荐使用】；三是线程抛出未捕获的异常。

package sc.thread;

public class Test01 {

public static void main(String[] args) {
    //Thread.MIN_PRIORITY  线程可以具有的最低优先级。1
    //Thread.MAX_PRIORITY  线程可以具有的最高优先级。10
    //Thread.NORM_PRIORITY  分配给线程的默认优先级。5
    //线程优先级高，被cpu调度的概率大，但不表示一定先运行。
    
    //主线程（main）的优先级（默认优先级）
    //Thread.currentThread()引用本线程,getPriority()返回线程的优先级。
    System.out.println(Thread.currentThread().getPriority());
    
    /*
    Thread01 t1=new Thread01("1窗口");
    t1.start();
    Thread01 t2=new Thread01("2窗口");
    t2.start();
    //线程调用start之后就处于活动状态。
    // 测试线程是否处于活动状态(线程是否运行)
    System.out.println(t2.isAlive());
    Thread01 t3=new Thread01("3窗口");
    // 设置线程的优先级
    t3.setPriority(Thread.MAX_PRIORITY);
    t3.start();
     * */
    
    
    
    
    Runnable01 r1=new Runnable01();
    Thread t4=new Thread(r1,"1窗口");
    t4.start();
    Thread t5=new Thread(r1,"2窗口");
    t5.start();
    Thread t6=new Thread(r1,"3窗口");
    t6.start();
    
    
    
    
    
    
    //调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行
    //join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。
    
    for (int i = 0; i <5; i++) {
        if (i==2){
            try {
                //join()  等待该线程终止。
                //等t5线程运行完    main主线程才运行
                
                t5.join();
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
            
            System.out.println(Thread.currentThread().getName()+"运行");
        }
        }
    /*
1窗口卖出一张票，还剩2张票
3窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩1张票
2窗口卖出一张票，还剩2张票
3窗口卖出一张票，还剩0张票
main运行
*/
    
    
    for (int i = 0; i <5; i++) {
        if (i==3){
            try {
                //如果i=3，当前线程休眠5000毫秒
                Thread.sleep(5000);
                //sleep()在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）休眠的线程进入阻塞状态
                System.out.println(Thread.currentThread().getName()+"->"+i+"运行");
            } catch (InterruptedException e) {
            
                e.printStackTrace();
            }
            
            }
            System.out.println(Thread.currentThread().getName()+"->"+i+"运行");
        
        }
        
}
}

package sc.thread;

public class Interrupt {
public static void main(String[] args) {
    
    Runnable01 r=new Runnable01();
    Thread t=new Thread(r,"1窗口");
    t.start();
    Thread t5=new Thread(r,"2窗口");
    t5.start();
    Thread t6=new Thread(r,"3窗口");
    t6.start();
    
    
    
    
    
    
/*当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也可以不理这次暗示。此时当前线程进入就绪状态。*/
    for (int i = 0; i < 5; i++) {
        if (i == 2) {
            // yield 使当前礼让一次
            Thread.yield();
            // yield 暂停当前正在执行的线程对象，并执行其他线程。（ 使当前礼让一次）
        }
        System.out.println("->" + i);
    }
    
}
}

package sc.thread;
/*同步概念:
 * 原子性操作:一个操作要么一次性做完，要么根本不开始，不存在中间状态。
案例:ATM取现操作
同步就是让操作保持原子性！java提供两种方式实现同步。

 * */
public class Runnable01 implements Runnable{
     private  int count=5;
    

    public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i <5; i++) {
            //同步代码块:
            //把所有的同步操作放到同步代码块中，synchronized (mutex) { // .. .}
            //mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。一般用共享资源作为同步锁，也称同步监视器。  
            //同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器
        //count是属性，不是对象，所以用this（this表示此类）
//加锁之后，当前线程必须把代码块执行完，解锁之后，其他线程才能访问
            synchronized (this) {
            //    
            if (count>0){
                
                count--;
                System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");
            }
            }}
        
    }

}

package sc.thread;

public class Interrupt {
public static void main(String[] args) {
    
    Runnable01 r=new Runnable01();
    Thread t=new Thread(r,"1窗口");
    t.start();
    Thread t5=new Thread(r,"2窗口");
    t5.start();
    Thread t6=new Thread(r,"3窗口");
    t6.start();
    

}
}
/*解决了前面的数据错乱：同步
 * 同步后：
 * 1窗口卖出一张票，还剩4张票
1窗口卖出一张票，还剩3张票
1窗口卖出一张票，还剩2张票
1窗口卖出一张票，还剩1张票
1窗口卖出一张票，还剩0张票*/
            

package sc.thread;



/*同步概念:
 * 原子性操作:一个操作要么一次性做完，要么根本不开始，不存在中间状态。
案例:ATM取现操作
同步就是让操作保持原子性！java提供两种方式实现同步。

 * */
public class Runnable01 implements Runnable{
     private  int count=5;
    

    public void run() {
        // 模拟一个窗口5个人
        for (int i = 0; i <5; i++) {
        
            this.saleTicket();
            }
        
            
    }
    // 同步方法默认对this加锁
    private synchronized void saleTicket() {
        if (count>0){
            count--;
         System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");    
    }
    }

}

死锁：

线程t1，拥有A资源，再次申请B资源，线程t2,拥有B资源，再申请A资源，t1因为没有申请到B资源而进入阻塞；t2因为没有申请到A资源进入阻塞。此时两个线程都处于阻塞状态而不能正常结束，而此时cpu空转，这种情况称为死锁。