多线程

1.1基本概念：程序、进程、线程

程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
进程：是程序的一次执行过程，或是正运行的一个程序。是动态的过程：有自身的产生、存在和消亡的过程。——声明周期
如：运行中的QQ
- 程序是静态的，进程是动态的
进程作为资源分配的单位，系统在运行时会为每个进程分配不同内存的区域
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行多个线程，就是支持多线程
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间的通讯更简便、高效。但多个线程操作共享系统资源可能就会带安全隐患

*** 虚拟机栈和程序计数器是一个线程一份，而方法区和堆是一个进程一份，所有所有线程共享方法区和堆 ***

1.2单核cpu和多核cpu:

单核cpu其实是一种假的多线程，因为在一个时间内只能执行一个线程任务。假如有A、B线程任务，单核CPU就是先执行一个然后挂起再去执行一会另一个，来回切换执行，但因为CPU时间特别短所以感觉不出来；
多核才能更好发挥多线程
一个Java应用程序最少三个线程：main()主线程、gc()垃圾回收线程，异常处理线程

1.3并行和并发

并行：多个CPU同时执行多个任务
并发：一个CPU（采用时间片）“同时”执行多个任务

1.4多线程的优点

1.提高应用程序的影响。对图形化界面更有意义，可增强用户体验

2.提高CPU利用率

3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

程序需要同时执行两个或多个任务
程序需要实现一些需要等待的任务，如用户输入，文件读写等
需要一些后台运行时的程序

2线程的创建和使用

2.1方式1：继承Thread类

1.创建一个基承Thread类的子类
2.重写Thread类的run()方法–>将此线程的操作声明在run方法中
3.创建Thread类的子类对象
4.通过此对象调用start()

/**
 *
 * 多线程的创建方式1：基础Thrad类
 *  * 1.创建一个基承Thread类的子类
 *  * 2.重写Thread类的run()方法-->将此线程的操作声明在run方法中
 *  * 3.创建Thread类的子类对象
 *  * 4.通过此对象调用start()
 *
 */
//1.创建一个基承Thread类的子类
class MyThread extends Thread{
//    2.重写Thread类的run()方法
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(i);
            }

        }

    }
}
public class ThreadTest  {
    public static void main(String[] args) {
//        3.创建Thread类的子类对象
        MyThread t1 = new MyThread();//主线程做的
//        4.通过此对象调用start():1启动当前线程；2调用当前线程的run()方法
        t1.start();//主线程做的之后run()操作才是支线

        //问题1：不会开启新线程，只是调用方法还是主线程
       //  t1.run();

        //问题二：在启动一个线程，遍历100以内的偶数。不可以让已经start()的线程去执行，会报异常
//        t1.start();

        //需要重写创建一个线程对象
        MyThread t2 = new MyThread();
        t2.start();


//        如下操作仍然是在main线程中执行
        for (int i = 0; i <100 ; i++) {
            if (i%2==0){
                System.out.println(i+"=====main=====");
            }

        }
    }
}

联习：创建两个线程，其中一个线程遍历100以内的偶数，另外一个遍历100以内的奇数

方法1
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2 !=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

方法2
public class ThreadDemo {
    public static void main(String[] args) {
//        创建Thread的匿名子类
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    if(i%2==0){
                              System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    if(i%2 !=0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
    }
}

2.2Thread中的常用方法

1.start():启动当前线程；调用当前线程的run()方法

2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread():静态方法，返回执行当前代码的线程

4.getName():获取当前线程的名字

5.setName():设置当前线程的名字

6.yield():释放当前cpu的执行权（重新抢）

7.join():在线程A中调用线程B的join（）方法，此时线程A进入阻塞状态，直到线程B执行完以后，A才能结束阻塞状态

8.stop():已过失，当执行此方法时强制结束线程

9.sleep(long millitime):让当前线程"睡眠"指定的millitime毫秒，在指定的时间内当前线程是阻塞状态

10.isAlive():判断当前线程是否还存活

 * 测试Thread中的常用方法
class HelloThread<publi> extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i%20==0){
                this.yield();
            }

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

public class ThreadMethodTest {
    public static void main(String[] args) {
        //通过构造器方式给线程命名
        HelloThread h1 = new HelloThread("Thread:1");
//        h1.setName("线程一");
        h1.start();
//        给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i==20){
                try {
                    h1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
        System.out.println(h1.isAlive());
    }
}

2.3线程的优先级

线程优先级等级
- MAX_PRIORITY:10
- MIN_PRIORITY:1
- NORM_PRIORITY:5
涉及的方法：
- getPriority():返回线程优先值
- setPriority(int newPriority):改变线程优先级
说明
- 线程创建时继承父类的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级之后才被调用

class HelloThread<publi> extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+getPriority()+":"+i);
            }
            if (i%20==0){
                this.yield();
            }

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

public class ThreadMethodTest {
    public static void main(String[] args) {
        //通过构造器方式给线程命名
        HelloThread h1 = new HelloThread("Thread:一");
//        h1.setName("线程一");
//        设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);
        h1.start();
//        给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }


        }

    }
}

联习：例子：创建三个窗口卖票，总票数为100

存在线程安全问题，待解决

class Window extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while(true){
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }

        }
    }

public class WindowTest {
    public static void main(String[] args) {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

如果不想给ticket加static需要用创建多线程的另一种方法

2.4方式2：实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象做为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }

    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
         MThread mThread = new MThread();
         //4.将此对象做为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5.通过Thread类的对象调用start()；1启动线程2调用当前线程run()-->调用Runnable类型中的target的run()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.start();


    }
}

联习：例子：创建三个窗口卖票，总票数为100

 //存在线程安全问题，待解决

class Window1 implements Runnable{
    private int ticket=100;

    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+":卖票，票号为"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}



public class WindowRunnableTest {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}

2.5两种方式的对比

开发中优先选择：实现Runnable接口的方式

原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合处理多个线程有共享数据的情况
联系：Thread类本身也是实现Runnable
相同点：两种方式都要重写run(),将线程要执行的逻辑声明在run()中

3线程的生命周期

五种状态：

新建：当一个Thread或其子类被对象声明并创建时
就绪：start()之后，已经具备运行的条件，只是没有分配到cpu资源
运行：当就绪的程序被调度并获得CPU资源时便进入了运行状态，run()方法定义了线程的操作和功能
阻塞：某种特殊情况下，被人为挂起或执行·1输入输出操作时，让出CPU并临时终止自己的执行。进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地终止或者异常导致结束

4线程的同步（解决线程安全问题）

1.问题：卖票过程中出现了重票。错票–>出现线程的安全问题

2.问题出现原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来也操作车票
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到该线程操作完，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能改变
4.在Java中，我们通过同步机制，来解决线程安全问题

方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

*** 说明：1.操作共享数据的代码，即为需要被同步的代码不能包含代码多了也不能少了
2.共享数据：多个线程共同操作的数据
3.同步监视器，俗称：锁。任何一个类的对象都可以充当锁
要求：多个线程必须要共用同一把锁 ***

同步代码块解决实现Runnable接口线程安全问题：

补充：在继承Thread类创建多线程方式中，慎用this当同步监视器，考虑使用当前类充当同步监视器

class Window1 implements Runnable{
    private int ticket=100;
    Object obj=new Object();


    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}


public class WindowRunnableTest {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

同步代码块解决继承Thread线程安全问题：

补充：在继承Thread类创建多线程方式中，慎用this当同步监视器，考虑使用当前类充当同步监视器

class Window extends Thread{
    private static int ticket=100;
    private Object obj=new Object();
    private static Object obj2=new Object();

    @Override
    public void run() {
        while(true){
          //  synchronized (obj) {此时不唯一
            synchronized (obj2){
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }

    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}