Day 1：线程与进程系列问题（一）

一、进程与线程

　　进程：正在执行的程序称为一个线程，主要负责内存空间的划分。

　 　线程：线程在一个进程中负责代码的执行，就是进程中的一个执行路径。

　　 多线程：在一个进程中有多个线程同时在执行不同的任务（同时指的是宏观上）。

　　Q：windows为多任务操作系统，那么它可以同时运行多个应用程序吗？

　　A：不可以，一次只能运行一个。单核CPU一个时间片中只能执行一个应用程序。

　　　　宏观上：同时运行           微观上：单个执行　　

　　Q：线程负责了代码的执行，那么我们没用到Thread类创建对象，为什么代码可以执行？一个JAVA程序至少有几个线程？

　　A：任何一个Java程序，在jvm运行的时候都会创建main线程执行main方法中的代码；

　　　　2个：main线程，垃圾回收器线程负责垃圾回收。

　　多线程的优点：1.解决一个进程可以执行多个任务的问题

　　　　　　　　　2.提高资源的利用率（不是效率）。

　　多线程的缺点:1.增加CPU的负担

　　　　　　　　 2.降低了进程中单线程的执行概率　　　　　　　　

　　　　　　　 　3.会引发线程安全问题

　　　　　　　　 4.会出现死锁现象

二、如何创建线程

方法一：

　　　1.自定义一个类继承Thread类

　　　2.该子类应重写 Thread 类的 run 方法

　　　3.创建该子类的实例对象，并调用start（）方法来开启线程，一个线程一旦开启，

　　　　那么线程就会执行run()方法中的代码，run()方法不能直接调用，直接调用run方法就相当于调用普通的方法，并没有开启新的线程。

---

     class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // 将自定义线程需要执行的代码放在run()方法中
              . . .
         }
     }
 

---

然后，下列代码会创建并启动一个线程：

     PrimeThread p = new PrimeThread(143);
     p.start();
 

方法二：

　　　　创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，

　　　　在创建 Thread 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：

---

     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
 

---

然后，下列代码会创建并启动一个线程：

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();
 

　　Q:为什么要重写run方法？目的是？

　　A:每个线程都有自己的任务代码，JVM创建主线程的任务代码为main方法中的所有代码

　　　自定义线程的任务代码就要写在run方法中，自定义线程负责run方法中的代码

eg:

public class Demo1 extends Thread {
 
    @Override
    public void run() {
        for(int i = 0;i<100;i++) {
            System.out.println("自定义线程"+i);
        }
    }
 
    public static void main(String[] args) {
 
        Demo1 a = new Demo1();
        a.start();
 
        for(int i = 0;i<100;i++) {
            System.out.println("main线程"+i);
        }
    }
}

三、线程的生命周期

　　图片借鉴

　　运行状态下线程一旦执行了sleep或者wait方法后，该线程会进入临时阻塞状态，如果线程是调用sleep方法进入该状态，一旦超过了指定的睡眠时间，

那么就会重新进入可运行状态，如果调运个了wait方法今日阻塞状态，那么就需要其他线程唤醒该线程才可以重新进入运行状态。

四、线程常用方法

Thread(String name)     初始化线程的名字
etName(String name)    设置线程对象名
getName()             返回线程的名字
sleep()                 线程睡眠指定的毫秒数。 静态的方法， 那个线程执行了sleep方法代码那么就是那个线程睡眠。
currentThread()      返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。
getPriority()             返回当前线程对象的优先级   默认线程的优先级是5(主线程优先级获取Thread.CurrentThread.getPriority();)

setPriority(int newPriority) 设置线程的优先级    虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。

 四、线程安全性问题

以一个程序为例：

class SaleTicket extends Thread{
 
     int num = 50;
 
     public SaleTicket(String name) {
        super(name);
    }
 
    public void run() {
        while(true){
                if(num>0){
                System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
            }else{
                System.out.println("售罄了..");
                break;
            }
        }
    }
}
public class Demo {
 
    public static void main(String[] args) {
        //创建三个线程对象，模拟三个窗口
        SaleTicket thread1 = new SaleTicket("窗口1");
        SaleTicket thread2 = new SaleTicket("窗口2");
        SaleTicket thread3 = new SaleTicket("窗口3");
        //开启线程
        thread1.start();
        thread2.start();
        thread3.start();
      }
}

问题1 ：为什么50张票被卖出了150次？

出现的原因：因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。

解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。

问题2： 出现了线程安全问题 ?

线程安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。
 
 java线程同步机制的方式：
  方式一：同步代码块
   同步代码块的格式：
    
    synchronized(锁对象){
     需要被同步的代码...
    }

同步代码块要注意事项：
  1. 任意的一个对象都可以做为锁对象。
  2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
  3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
  4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
 

 方式二：同步函数（暂时没学到，后期更新）

出现线程安全问题的根本原因：
 1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
 2. 有多个语句操作了共享资源。

正确代码：

class SaleTicket extends Thread{
 
     static int num = 50;//票数  非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
 
     static    Object o = new Object();
 
     public SaleTicket(String name) {
        super(name);
    }
 
    public void run() {
        while(true){
            //同步代码块
            synchronized ("锁") {
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                }else{
                    System.out.println("售罄了..");
                    break;
                }
            }
        }
    }
} 
 
public class Demo4 {
 
    public static void main(String[] args) {
        //创建三个线程对象，模拟三个窗口
        SaleTicket thread1 = new SaleTicket("窗口1");
        SaleTicket thread2 = new SaleTicket("窗口2");
        SaleTicket thread3 = new SaleTicket("窗口3");
        //开启线程售票
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

课后习题：一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取100块，要求不准出现线程安全问题。

学习自测代码：

public class Demo2 extends Thread {
 
 static int money = 5000;
    static Object lock = new Object();
   
 public Demo2(String name) {
  super(name);
 }

public void run() {
  while(true) {
   synchronized (lock) {
    if(money>0) {
     System.out.println(Thread.currentThread().getName()+"取走100元，还剩"+(money-100)+"元！");
     money-=100;
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }else {
     System.out.println("银行卡没有存款了！");
     break;
    } 
   }
  }
 }
 
 public static void main(String[] args) {
  Demo2 men = new Demo2("男士");
  Demo2 women = new Demo2("女士");
  
  men.start();
  women.start();
 }

}