java之多线程

1.什么是进程、什么是线程？

　　进程是一个应用程序，或者一个软件

　　线程是一个进程中的执行场景、执行单元

　　一个进程可以启动多个线程。

对于java程序来说，当在dos命令窗口输入：java helloWorld 回车之后，会先启动JVM，而JVM就是一个进程。

JVM在启动一个主线程，调用main方法。同时在启动一个垃圾回收线程负责看护，回收垃圾。

至少有两个线程并发：①垃圾回收线程 ②执行main方法的主线程

2.进程和线程什么关系？举个例子：

　　阿里巴巴：进程

　　马云：阿里巴巴的一个线程

　　董文红：阿里巴巴的一个线程

　　京东：进程

　　刘强东：京东的一个线程

　　张泽天：京东的一个线程

　　进程可以看做是现实生活当中的一个公司

　　线程可以看做是现实生活当中的某个员工

　　注意：进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享）

　　　　　例：

　　　　　　魔兽游戏是一个进程

　　　　　　酷狗音乐是一个进程

　　　　　　这两个进程是独立的，不共享资源。

　　　　   线程A和线程B呢？（有些共享，有些不共享）

　　在java语言当中呢，就是线程a和线程b，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈，互相不影响，都在进行各自的压栈弹栈。

　　假设启动10个线程，会有10个栈空间，每个栈之间互不干扰，各自执行各自的，这就是多线程并发。

 

      　　例：

　　　　　　火车站：可以看做一个进程

　　　　　　火车站的每个售票窗口：可以看做是一个线程。

　　　　A在窗口1购票，B可以在窗口2购票，两个人不用等对方，所以并发可以提高效率。

多线程并发：

　　对于多核的CPU电脑来说，真正的多线程并发是没有问题的。

　　4核CPU表示同一时间点上，可以真正的有4个进程并发。

　　1.什么是真正的多线程并发？

　　　　t1线程执行t1.

　　　　t2线程执行t2.

　　　　t1不会影响t2，t2也不会印象t1.这叫做真正的多线程并发。

　　单核的cpu表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核cpu来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人的感觉是，多个事情同时在做。

　　　　　　线程A：魔兽游戏

　　　　　　线程B：酷狗音乐

　　　　　　线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。

　　电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生的错觉，感觉是动画的。

看下面一段代码，分析一下，有几个线程？

/*
* 分析一下以下代码有几个线程
* 1个线程，因为程序只有一个栈*/

public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");

    }

    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    private static void m3() {
        System.out.println("execute");
    }
}

java语言中实现线程的方式：

 1.编写一个类，直接继承java.lang.Thread,重写run方法。

//定义线程类

public class MyThread extends Thread{
    @Override
    public void run(){

    }
}
//创建线程对象

MyThread t = new MyThread();

//启动线程
t.start();

package thread;
/*实现线程的第一种方式
编写一个类，直接结成java.lang.Thread,重写run方法。

怎么创建线程对象？new就行了
怎么启动线程呢？ 调用线程对象的start()方法。
* */

public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行
        //新建一个分支线程对象
        MyThread t = new MyThread();

        //启动线程
        //t.run(); //如果直接调用run、而不用start，是不会启动线程，不会分配新的分支栈，这种方式就是单线程
        /*
        start方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成吼瞬间就结束了
        这段代码的任务只是为了开启一个新的栈空间，只要新的空间栈开出来，start()方法就结束，线程就启动成功
        这段成功的线程会自动调用run方法，并且run方法在分支栈的底部（压栈）。
        run方法在分支栈的底部，main方法在主栈的栈底部。run和main是平级的
         */

        t.start();
        //这里的代码还是运行在主线程中
        for (int i = 0;i<1000; i++){
            System.out.println("主线程----》"+ i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run(){
        //编写程序，这段程序运行在分支线程中（分支线）
        for (int i = 0;i<1000; i++){
            System.out.println("分支线程----》"+ i);
        }
    }
}

思考：如果调用run而不调用start方法会是什么样子？

package thread;
/*实现线程的第一种方式
编写一个类，直接结成java.lang.Thread,重写run方法。

怎么创建线程对象？new就行了
怎么启动线程呢？ 调用线程对象的start()方法。
* */

public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行
        //新建一个分支线程对象
        MyThread t = new MyThread();

        t.run(); //如果直接调用run、而不用start，是不会启动线程，不会分配新的分支栈，这种方式就是单线程
       
        //t.start();
        //这里的代码还是运行在主线程中
        for (int i = 0;i<1000; i++){
            System.out.println("主线程----》"+ i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run(){
        //编写程序，这段程序运行在分支线程中（分支线）
        for (int i = 0;i<1000; i++){
            System.out.println("分支线程----》"+ i);
        }
    }
}

结果是先执行完了run方法，输出了0-999之后，才运行了主方法里面的输出0-999.内存图如下：

 2.第2种方式

编写一个类实现java.lang.Runnable接口

//定义一个可运行的类

class MyRunnable implements Runnable{

    public void run() {
       
    }
}

//创建线程对象

Thread t = new Thread(new MyRunnable());

//启动线程

t.start();

/*
* 实现线程的第二种方式，编写一个类实现java.lang.Runnable接口*/

public class ThreadTest03 {
    public static void main(String[] args) {
        //1.创建一个可运行的对象
        MyRunnable r = new MyRunnable();
        //2.将可运行的对象封装成一个线程对象
        Thread t = new Thread(r);
        
        /*1和2可以合并成下面一行代码*/
        //Thread t = new Thread(new MyRunnable());
        
        /*1和2也可以合并成匿名类写法如下，不需要写MyRunnable类*/
        /*
        Thread t = new Thread(new Runnable() {
            public void run() {
                for (int i = 0;i<100; i++){
                    System.out.println("分支线程----》"+ i);
                }
            }
        });
        * */
        
        
        //启动线程
        t.start();

        for (int i = 0;i<100; i++){
            System.out.println("主线程----》"+ i);
        }

    }
}


class MyRunnable implements Runnable{

    public void run() {
        for (int i = 0;i<100; i++){
            System.out.println("分支线程----》"+ i);
        }
    }
}

线程的生命周期：

 操作线程的名字：

/*
* 1.怎么获取当前线程对象？
* Thread t = Thread.currentThread();
* 返回t就是当前对象
* 2.获取线程对象的名字
* 线程对象.getName();
* 3.修改线程对象的名字
* 线程对象.setName("线程名字");
* 4.当线程没有设置名字的时候，默认的名字有什么规律？
* Thread-0
* Thread-1
* Thread-2
* Thread-3
* */

public class ThreadTest04 {
    public static void main(String[] args) {

        //currentThread就是当前线程对象
        /*这个代码出现在main方法当中，所以当前线程就是主线程*/
        System.out.println(Thread.currentThread());

        //创建一个线程对象
        MyThread4 t = new MyThread4();
        //设置线程的名字
        t.setName("T1");
        //获取线程的名字
        System.out.println(t.getName());


        MyThread4 t1 = new MyThread4();
        t1.setName("T2");
        System.out.println(t1.getName());

        //启动线程
        t1.start();
        t.start();
    }

}


class MyThread4 extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中（分支线）
        //currentThread()就是当前线程对象，当前线程是谁呢？
        /*那个线程启动，一旦运行到方法，就是那个线程
        当t1线程执行run方法，那么这个线程就是t1
        当t2线程执行run方法，那么这个线程就是t2
        * */
        for (int i = 0;i<10; i++){
            //System.out.println("分支线程----》"+ i);
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}

 /*

关于线程的sleep方法：

static void sleep(long millis)

1、静态方法

2、参数是毫秒

3、作用：让当前线程进入休眠状态，进入‘阻塞状态’，放弃占有CPU时间片，让给其他线程使用

　　这行代码出现在A线程中，A线程就会进入休眠

　　这行代码出现在B线程中，B线程就会进入休眠

4、Thread.sleep()方法，可以做到，间隔特定的时间，去执行特定的代码，每隔多久执行一次

*/

public class ThreadTest05 {
    public static void main(String[] args) {

        //让当前线程进入休眠，睡眠5秒,当前线程是主线程！！！
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //5秒之后出现该代码
        System.out.println("Hello world");

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"---->"+i);
            //睡眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

叫醒线程的方法：用Thread.interrupt()方法

/*

一个线程sleep睡眠太久了，如果希望半道上醒来，应该怎么做？也就是说怎么侥幸一个正在睡眠的线程？？

注意：这个不是终断线程的执行，而是终止线程的睡眠

*/ 

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();

        //希望5s之后，t线程醒来(5s之后，手里的活干完了)
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {

            //打印异常的信息
            e.printStackTrace();
        }

        //中断t线程的睡眠（这种中断睡眠的方式，依靠的是java的异常处理机制）
        t.interrupt(); //干扰，一盆冷水过去

    }
}


class MyRunnable6 implements Runnable{

    /**重点：run(）当中的异常不能throws，只能try catch。
     * 因为run方法在父类中没有抛出任何的异常，子类不能比父类抛出更多的异常
     * */
    public void run() {

        //休眠一年
        System.out.println(Thread.currentThread().getName()+ "---->" + "begin");
        try {
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            //打印异常的信息,也可以不打印出来，直接注释掉
           e.printStackTrace();
        }

        //一年之后才可以执行这里
        System.out.println(Thread.currentThread().getName()+ "---->" + "end");
    }
}