Java基础学习第十八天（进程、线程）

一、进程

1、进程：正在执行的程序称作为一个进程，进程负责了内存空间的划分。

2、问题： windows号称是多任务的操作系统,那么windows是同时运行多个应用程序吗？
① 从宏观的角度： windows确实是在同时运行多个应用程序。
② 从微观角度： cpu是做了一个快速切换执行的动作，由于速度态度，所以感觉不到在切换而已。

二、线程

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

2、多线程：在一个进程中有多个线程同时在执行不同的任务。

3、线程负责了代码的执行，我们之前没有学过线程，为什么代码可以执行呢？
运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。

4、一个java应用程序至少有几个线程？
至少有两个线程，一个是主线程负责main方法代码的执行，一个是垃圾回收器线程，负责了回收垃圾。

5、多线程的好处
① 解决了一个进程能同时执行多个任务的问题
② 提高了资源的利用率

6、多线程的弊端
① 增加cpu的负担
② 降低了一个进程中线程的执行概率
③ 引发了线程安全问题
④ 出现了死锁现象

三、自定义线程的方式

1、创建线程的方式一
① 自定义一个类继承Thread类。
② 重写Thread类的run方法，把自定义线程的任务代码写在run方法中
③ 创建Thread的子类对象，并且调用start方法开启线程。

疑问：重写run方法的目的是什么？
每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码，自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。
注意：一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。

public class Demo18.1 extends Thread {  
    @Override //把自定义线程的任务代码写在run方法中。
    public void run() {
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("自定义线程："+i);
        }
    }   
    public static void main(String[] args){
        //创建了自定义的线程对象
        Demo18.1 d = new Demo18.1();
        //调用start方法启动线程
        d.start();  
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("main线程："+i);
        }
    }   
}

 //需求： 模拟QQ视频与聊天同时在执行
class TalkThread extends Thread{    
    @Override
    public void run() {
        while(true){
            System.out.println("正在聊天...");
        }
    }
}
class VideoThread extends Thread{   
    @Override
    public void run() {
        while(true){
            System.out.println("正在视频....");
        }
    }
}
public class Demo18.2{  
    public static void main(String[] args) {
        TalkThread talkThread = new TalkThread();
        talkThread.start();
        VideoThread videoThread = new VideoThread();
        videoThread.start();    
    }
}

2、线程常用的方法

常用方法	解释
Thread(String name)	初始化线程的名字
setName(String name)	设置线程对象名
getName()	返回线程的名字
sleep()	线程睡眠指定的毫秒数。静态的方法，哪个线程执行了sleep方法代码那么就是哪个线程睡眠
currentThread()	返回当前的线程对象，该方法是一个静态的方法，注意：哪个线程执行了这个方法代码就返回那个线程的对象
getPriority()	返回当前线程对象的优先级，默认线程的优先级是5
setPriority(int newPriority)	设置线程的优先级虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10，最小的1，默认是5）

public class Demo18.3 extends Thread {
    public Demo18.3(String name){
        super(name); //调用了Thread类的一个参数的构造方法
    }   
    @Override
    public void run() {
        System.out.println("this:"+ this);
        System.out.println("当前线程对象：" + Thread.currentThread());         
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);             
        try {
            Thread.sleep(100);  //为什么在这里不能抛出异常，只能捕获？Thread类的run方法没有抛出异常类型，所以子类不能抛出异常类型
        } catch (InterruptedException e) {
            e.printStackTrace();
            } 
        }   
    }       
    public static void main(String[] args) throws InterruptedException {
        //创建了一个线程对象
        Demo18.3 d = new Demo18.3("狗娃");
        d.setPriority(10); //设置线程的优先级：优先级的数字越大，优先级越高，优先级的范围是1~10
        d.start();      
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

        System.out.println("自定义线程的优先级："+d.getPriority());  //线程的优先级默认是5
        System.out.println("主线程的优先级："+Thread.currentThread().getPriority());    
        d.start();      
        d.setName("铁蛋"); //setName设置线程的名字
        d.start(); //开启线程 

        Thread mainThread = Thread.currentThread();
        System.out.println("主线程的名字："+ mainThread.getName());
    }
}

3、需求：模拟3个窗口同时在售50张票。
问题1 ：为什么50张票被卖出了150次？
出现的原因：因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的，三个线程对象就会有三份。
解决方案：把num票数共享出来给三个线程对象使用，使用static修饰。
问题2：出现了线程安全问题 ?
线程安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。

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

class SaleTicket extends Thread{    
     static int num = 50;//非静态的成员变量数据是在每个对象中都会维护一份数据的    
     static Object o = new Object();
     public SaleTicket(String name) {
        super(name);
    }   
    @Override
    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 Demo18.4{  
    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();        
    }   
}

4、java线程同步机制的方式
① 方式一：同步代码块
格式：

synchronized(锁对象){
    需要被同步的代码...
}

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

② 方式二：同步函数：使用synchronized修饰一个函数
同步函数要注意的事项：如果是一个非静态的同步函数的锁对象是this对象，如果是静态的同步函数的锁对象是当前函数所属的类的字节码文件（class对象）。同步函数的锁对象是固定的，不能由你来指定的。

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

class BankThread extends Thread{    
    static int count = 5000;    
    public BankThread(String name){
        super(name);
    }   
    @Override
    public void run() {
        getMoney();
    }       
    //静态的函数，函数所属的类的字节码文件对象：BankThread.class，唯一的
    public static synchronized void getMoney(){ 
       while(true){         
            if(count>0){
                System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");
                count= count - 1000;
            }else{
                System.out.println("取光了...");
                break;
            }
        }   
    }   
}
public class Demo18.5{
    public static void main(String[] args) {
        //创建两个线程对象
        BankThread thread1 = new BankThread("老公");
        BankThread thread2 = new BankThread("老婆");
        //调用start方法开启线程取钱
        thread1.start();
        thread2.start();    
    }   
}

推荐使用：同步代码块。
原因：同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定的，不能由我们来指定。同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。

5、创建线程的方式二：使用Runnable接口
该类中的代码就是对线程要执行的任务的定义.
① 自定义一个类实现Runnable接口
② 重写Runnable接口中的run方法，就是将线程运行的代码放入在run方法中
③ 创建Thread类实现类对象
④ 创建Runnable类的对象，作为实际参数传递给Thread类构造方法
⑤ 调用Thread类的start方法开启线程

问题1：请问Runnable实现类的对象是线程对象吗？
Runnable实现类的对象并不是一个线程对象，只不过是实现了Runnable接口的对象而已。只有是Thread或者是Thread的子类才是线程对象。
问题2：为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？
作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。

public class Demo18.6 implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }   
    public static void main(String[] args) {
        //创建Runnable实现类的对象
        Demo18.6 d = new Demo18.6();
        //创建Thread类的对象， 把Runnable实现类对象作为实参传递。
        Thread thread = new Thread(d,"狗娃");  //Thread类使用Target变量记录了d对象
        //调用thread对象的start方法开启线程
        thread.start();     
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }       
    }   
}

推荐使用：第二种，实现Runable接口的。
原因：因为java单继承，多实现的。

class SaleTicket implements Runnable{   
    int num = 50; // 票数 
    @Override
    public void run() {
        while(true){
            synchronized ("锁对象") {
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");
                    num--;
                }else{
                    System.out.println("售罄了..");
                    break;
                }   
            }
        }       
    }
}
public class Demo18.7{  
    public static void main(String[] args) {
        //创建了一个Runnable实现类的对象
        SaleTicket saleTicket = new SaleTicket();
        //创建三个线程对象模拟三个窗口
        Thread thread1 = new Thread(saleTicket,"窗口1");
        Thread thread2 = new Thread(saleTicket,"窗口2");
        Thread thread3 = new Thread(saleTicket,"窗口3");
        //开启线程售票
        thread1.start();
        thread2.start();
        thread3.start();                
    }
}

6、java中同步机制解决了线程安全问题，但是也同时引发死锁现象。
死锁现象出现的根本原因：
① 存在两个或者两个以上的线程。
② 存在两个或者两个以上的共享资源。
死锁现象的解决方案：没有方案，只能尽量避免发生而已。

class DeadLock extends Thread{  
    public DeadLock(String name){
        super(name);
    }   
    public void run() {
        if("张三".equals(Thread.currentThread().getName())){
            synchronized ("遥控器") {
                System.out.println("张三拿到了遥控器，准备去拿电池!");
                synchronized ("电池") {
                    System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
                }
            }
        }else if("狗娃".equals(Thread.currentThread().getName())){
            synchronized ("电池") { 
                System.out.println("狗娃拿到了电池，准备去拿遥控器!");
                synchronized ("遥控器") {
                    System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
                }
            }           
        }   
    }   
}
public class Demo18.8{
    public static void main(String[] args) {
        DeadLock thread1 = new DeadLock("张三");
        DeadLock thread2 = new DeadLock("狗娃");
        //开启线程
        thread1.start();
        thread2.start();        
    }   
}