Java第十五章

一.线程和进程
1.进程的相关概念：每个独立运行的程序称为进程。例如QQ音乐。腾讯QQ。
2.线程的相关概念：每个进程又可以同时拥有多个线程。并且线程是可以同时执行的。一个进程最少拥有一个线程。
例如运行QQ音乐这个进程。它可以同时听歌，看视频，搜索歌曲。至少在执行3个线程。

当我们运行Java程序，就可以理解为开启了一个进程。
其中该进程下默认的一条进程就是main线程。

可以通过创建多个线程类，实现java的多线程。

如果没有使用多线程，代码的执行顺序就是从上到下依次执行。

例如：先听歌，再吃饭，再看电视，再聊天。如果是单线程，就只能一个一个按顺序执行。
如果是多线程：就可以一边听歌，一边吃饭，一边看电视，一边聊天。

多线程的应用场景：多用户同时使用的场景
例如：春节抢票 、  双十一购物 等 。高并发场景。

高并发：多个事件在同一个时间段发生。 例如同时吃饭和聊天。
高并行：多个事件在同一个时刻发生。 例如同时吃饭和听歌。

解决的最常见方式：利用多线程

二.如何创建线程
与线程相关的类和方法都处于：  Java.lang.Thread下 所以无需导包。

线程类的创建方法：（先有线程类。再有线程）
1.继承Thread类

2.重写run方法(线程的代码体都放在run方法里面)

3.创建对象

4.调用start方法

备注：线程的执行权是随机的。

由于Java是单继承，所以一般能不继承就不继承，把继承的机会让给更重要的类。

所以一般都是使用下面这种方式来创建线程。

1.实现runnable接口

2.实现run方法(线程的代码体都放在run方法里面)

3.创建上述类对象

4.创建线程对象，然后将第三步的对象作为参数传递。

5.调用start方法
        
    A a = new A();
    a.start();
    
    B b = new B();
    Thread t = new Thread(b);
    t.start();
    
    for(int i = 1;i<=100;i++) {
        System.out.println("这是main线程" + i);
        }
            
    }
}

class  A extends Thread{
    public void run() {
        for(int i = 1;i<=100;i++) {
            System.out.println("这是A线程" + i);
        }
    }
}

class B implements Runnable{
    @Override
    public void run() {
        for(int i = 1;i<=100;i++) {
            System.out.println("这是B线程" + i);
    }
}

三.线程的相关方法
Thread.currentThread() 获取当前线程

Thread.currentThread().setName() 给当前线程取一个别名

Thread.currentThread().getName() 获取当前线程的别名

Thread.sleep(long x); 让当前线程暂停x毫秒。让别的线程先执行。

isAlive();获取该线程是否活跃
A1 a = new A1();
Thread t = new Thread(a);
t.start();

System.out.println(Thread.currentThread().isAlive());//true
System.out.println(111);
Thread.sleep(3000);
System.out.println(222);
System.out.println(Thread.currentThread().isAlive());//true

System.out.println("A1线程是否活跃" + t.isAlive());
                }
       }
}

class A1 implements Runnable{
    @Override
    public void run() {
        System.out.println(111);
       }
}

四.CPU和平均调度
CPU负责：执行线程。 那么存在多个线程，优先级是怎么样的？  随机的

计算机：平均调度。理解为雨露均沾，每个线程都是平等的，都是同等的机会被CPU执行。

Java：抢占时调度，理解为每个线程可以设置一个优先级。可以优先执行该线程。
但是至于抢不抢的过，还是随机的。

Java中每个线程默认优先级都是5，最大为10，最小为1；
Thread.currentThread().setPriority(xxx);
Thread.currentThread().getPriority(xxx)；
        
        Thread t = new Thread(new A2());
        
        t.setName("这是A2线程");
        Thread.currentThread().setName("main");
        t.setPriority(10);
        Thread.currentThread().setPriority(1);
        t.start();
        
        for(int i = 0 ;i<100;i++) {
            System.out.println(Thread.currentThread().getName() + i);
    }
        
}

class A2 implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ;i<100;i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    
}

五.线程的生命周期
1.新建态：创建了一个线程还没有通过start方法开启。

2.就绪态：调用了start方法，但是还没有开始执行。   或阻塞态结束。

3.运行态：抢到了CPU资源，正在执行中。

4.阻塞态：在运行态的过程中，出现一点意外（例如：被别的线程抢去了cpu资源，调用了sleep,yield等方法）

5.消亡态：线程执行完毕。

六.例题1
public static void main(String[] args) {
    upload1();    
}

public static void upload1() {
    //有会员的网盘下载
for(int i = 1;i<=100;i++) {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println("下载进度为：" + i + "%");
        }
    }
}

七.例题2
public static void main(String[] args) {    
创建一个类，该类有3个方法，分别是吃饭睡觉打豆豆。
每个方法需要执行5秒。
//        long t1 = System.currentTimeMillis();
//        a1();
//        a2();
//        a3();
//        long t2 = System.currentTimeMillis();
//        System.out.println(t2-t1);单线程执行时间约等于15秒
        
        
        long t11 = System.currentTimeMillis();
        Thread t1 = new Thread(new A4());
        Thread t2 = new Thread(new A5());
        Thread t3 = new Thread(new A6());
        t1.start();
        t2.start();
        t3.start();
        //下面的写法是无法正确计算结果的。因为多线程的特性，不会等t1t2t3执行完。而是main自己先执行完了
//        long t22 = System.currentTimeMillis();
//        System.out.println(t22-t11);
        
        //t1 t2 t3都要执行完毕才可以执行下面这行代码
        //t1 t2 t3 都处于死亡状态  isAlive返回值都要为false 才可以开始计算时间
        
        while(true) {
            if(t1.isAlive()==false && t2.isAlive()==false && t3.isAlive()==false ) {
                long t22 = System.currentTimeMillis();
                System.out.println(t22-t11);
                break;
            }
        }
    }
    
    public static void a1() {
        System.out.println("吃饭中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("吃饭结束");
    }
    
    public static void a2() {
        System.out.println("睡觉中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("睡觉结束");
    }
    
    public static void a3() {
        System.out.println("打豆豆中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("打豆豆结束");
    }
}

class A4 implements Runnable{
    @Override
    public void run() {
        System.out.println("吃饭中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("吃饭结束");
    }
}

class A5 implements Runnable{
    @Override
    public void run() {
        System.out.println("睡觉中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("睡觉结束");
    }
}

class A6 implements Runnable{
    @Override
    public void run() {
        System.out.println("打豆豆中");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("打豆豆结束");
    }
}

八.例题3
public static void main(String[] args) {
创建一个线程类，功能是卖票。初始为100张票。
然后定义三个线程对象，同时开启，理解为3个窗口同时卖票。

I i = new I();
Thread t1 = new Thread(i);
Thread t2 = new Thread(i);
Thread t3 = new Thread(i);
t1.setName("窗口1：");
t2.setName("窗口2：");
t3.setName("窗口3：");
t1.start();
t2.start();
t3.start();

//该案例的写法是没有任何问题的  但是结果是不合人意的。
//原因： 由于Java线程是抢占行   如果多个线程同时操作相同的变量 。会出现读写错误。
//如何解决：见test9
    
}
    
}
class I implements Runnable{
    
    int num = 100;//表示票的总数
    public void run(){
        
        while(true) {
            num--;
            if(num<0) {
                System.out.println("票卖完了");
                break;
            }else {
                System.out.println(Thread.currentThread().getName() + "卖了第" + (100-num) +  "张票");
            }
        }        
    }
}