Java第二十天

1. 1. 程序和进程

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

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

1. 操做系统的发展

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

 

引入进程的概念

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

 

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

 

多任务操做系统

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

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

 

CPU时间片

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

 

并行:

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

 

线程的引入

解决实时性问题

 

1. 进程和线程区别

 

综合性案例

 

1. 多线程实现

Thread 类位于java.lang中，表示进程中的执行线程。实现多线程有两种方式
 

继承Thread和实现Runnable接口实现多线程的优缺点

[1] 继承Thread的线程类不能再继承其余类，实现Runnable接口的类还能够继承其余类。

[2] 实现Runnable接口的线程类，可让多个线程共享线程实现类的资源。

 

1. 线程的生命周期

新生状态 用new关键字创建一个线程后，该线程对象就处于新生状态。 处于新生状态的线程有本身的内存空间，经过调用start()方法进入就绪状态。   就绪状态 处于就绪状态线程具有了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。 当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动做称为“CPU调度”。 运行状态 在运行状态的线程执行本身的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。 若是在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。 阻塞状态 处于运行状态的线程在某些状况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时中止本身运行，进入阻塞状态。 在阻塞状态的线程不能进入就绪队列。只有当引发阻塞的缘由消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，从新到就绪队列中排队等待，被系统选中后从原来中止的位置开始继续执行。 死亡状态 死亡状态是线程生命周期中的最后一个阶段。线程死亡的缘由有三个，一个是正常运行 的线程完成了它的所有工做；另外一个是线程被强制性地终止，如经过stop方法来终止一个 线程【不推荐使用】；三是线程抛出未捕获的异常。

 

 

1. 线程经常使用方法
   1. [1]线程优先级

public static void main(String[] args) {                   System.out.println(Thread.MIN_PRIORITY);          System.out.println(Thread.MAX_PRIORITY);          System.out.println(Thread.NORM_PRIORITY);                   //主线程的优先级（默认优先级）          System.out.println(Thread.currentThread().getPriority());                            Thread01 t1 = new Thread01();          // 设置线程的优先级          t1.setPriority(Thread.MAX_PRIORITY);          t1.start();                            Thread01 t2 = new Thread01();          // 设置线程的优先级          t2.setPriority(Thread.MIN_PRIORITY);          t2.start();                        }

线程优先级高，被cpu调度的几率大，不表示必定先运行。

 

1. [2]isAlive

判断线程是否处于活动状态。

Thread01 t1 = new Thread01();          System.out.println(t1.isAlive());          // 设置线程的优先级          t1.setPriority(Thread.MAX_PRIORITY);          t1.start();          System.out.println(t1.isAlive());

线程调用start以后就处于活动状态。

 

1. [3]join

调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行

join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常。

 

public class Test02 {      public static void main(String[] args){                   Thread02 t = new Thread02("线程A");          t.start();                   for (int i = 0; i < 5; i++) {                             if(i == 2) {                    try {                        t.join();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }               }                             System.out.println(Thread.currentThread().getName() + "->" + i);          }      } }

 

1. [4]sleep()

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。

public static void main(String[] args) {                 Thread03 t = new Thread03("线程A");         t.start();                 Thread mainThread = Thread.currentThread();         System.out.println(mainThread.getName()+"即将进入休眠");         try {             Thread.sleep(5000);         } catch (InterruptedException e) {             e.printStackTrace();         }                 // 中断线程         t.interrupt();                 System.out.println(mainThread.getName()+"休眠完成");     }

 

1. [5] yield()

public static void main(String[] args) {            Thread mainThread = Thread.currentThread();            Thread04 t = new Thread04("线程A");          t.start();                     for (int i = 0; i < 5; i++) {               if (i == 2) {                    // yield 使当前礼让一次                    Thread.yield();               }               System.out.println(mainThread.getName() + "->" + i);          }      }

 

A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.

 

当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也能够狐狸此次暗示。此时当前线程进入就绪状态。

 

[6] 线程的终止。

目前而言，不推荐使用stop直接终止线程。用interrupt()方法去中断正在执行的线程，而在线程内部必定要写捕获中断的异常。经过异常处理机制正常结束线程。

 

1. 线程的安全问题(线程同步)

线程在执行过程当中，经过cpu的调度，执行轨迹不肯定，对共享资源的访问很容易形成数据的错误。咱们称这个错乱称为线程安全问题。

 

1. 同步概念

原子性操做:一个操做要么一次性作完，要么根本不开始，不存在中间状态。

案例:ATM取现操做

 

同步就是让操做保持原子性！java提供两种方式实现同步。

1. 同步代码块

把全部的同步操做放到同步代码块中，

synchronized (mutex) {    // .. . }

 

mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。通常用共享资源做为同步锁，也称同步监视器。

public class MyRun implements Runnable {           // 共享资源      private int count = 5;        @Override      public void run() {          // 模拟一个窗口5我的          for (int i = 0; i < 5; i++) {               // 同步代码块               // mutex 互斥锁               synchronized (this) {                    if (count > 0) {                                               try {                             Thread.sleep(3000);                             count--;                        } catch (InterruptedException e) {                             e.printStackTrace();                        }                                               System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");                    }               }          }      } }

 

总结

synchronized(obj){}中的obj称为同步监视器

同步代码块中同步监视器能够是任何对象，可是推荐使用共享资源做为同步监视器

 

1. 同步方法

若是同步代码(原子性)不少，能够考虑使用同步方法。

把普通方法用 synchronized 修饰，同步方法的同步监视器是this。

public class MyRun implements Runnable {         // 共享资源     private int count = 5;       @Override     public void run() {         // 模拟一个窗口5我的         for (int i = 0; i < 5; i++) {                         this.saleTicket();                     }     }         // 同步方法默认对this加锁     private synchronized void saleTicket() {         if (count > 0) {                         try {                 Thread.sleep(3000);                 count--;             } catch (InterruptedException e) {                 e.printStackTrace();             }                         System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票");         }     }

 

1. 死锁(C)

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