Java架构学习（一）多线程快速入门_java快速学会线程-CSDN博客

本文链接：https://blog.csdn.net/leeue/article/details/80576686

第一节进程与线程的区别

什么是进程？：进程就是正在运行的程序，他是线程的集合。

什么是线程？: 线程就是一条执行路径，一个独立的执行单元。

什么是多线程？：多线程就是提高程序的效率。

注意：
多线程并不是提高带宽速度，而是提高程序的效率，如：多线程下载
断点续传。

具体如图：
这里写图片描述

第二节：为什么要用多线程

多线程就是提高程序的效率，所以要使用多线程

第三节：多线程应用场景

多线程的应用场景：
            多线程下载、QQ、爬虫、前端的ajax、
            分布式JOb、使用多线程就是提高程序的效率

第四节：多线程创建方式

多线程共有5种创建方式：
    1、继承Thread类。
    2、实现Runnable接口。
    3、使用匿名内部类方式创建。
    4、使用callable  jdk1.5里面。
    5、使用线程池来创建 线程池是企业经常用的方式来创建线程。

第一种：继承Thread类来创建线程

package com.leeue.thread;
/**
 * 
 * @classDesc: 功能描述:(如何创建多线程)
 * @author:李月
 * @Version:v1.0
 * @createTime:@Date 2018年6月4日 下午4:31:10
 *
 */

class CreateThreadDemo02 extends Thread{
    /**
     * run方法就是线程需要执行的任务或者执行的代码
     */
    @Override
    public void run() {
        for(int i = 0; i < 30; i++){
            System.out.println("run:i"+i);
        }
    }
}
public class ThreadDemo02 {

    /**
     * 什么是进程？进程就是正在运行的应用程序，进程是线程的集合。
     * 什么是线程？线程就是一条执行路径，一个独立的执行单元。
     * 什么是多线程？为了提高程序的效率。
     * 创建线程有哪些方式？
     * 1、使用继承Thread类方式
     *    继承Thread类，重写run()方法。
     * 2、使用实现runlable接口方式
     * 3、使用匿名内部类的方式
     * 4、callable
     * 5、使用线程池创建线程，在企业里通常使用线程池来创建
     */
    public static void main(String[] args) {

        //1. 怎么调用线程
        CreateThreadDemo01 t1 = new CreateThreadDemo01();
        //2.启动线程，不是调用run方法，而是调用start方法
        t1.start();//开启多线程后，代码不会从上往下执行

        for(int i = 0; i < 30; i++){
            System.out.println("main,i="+i);
        }
    }
}

第二种：实现Runnable接口，重写run()方法创建线程。

package com.leeue.thread;
/**
 * 
 * @classDesc: 功能描述:(如何创建多线程)
 * @author:李月
 * @Version:v1.0
 * @createTime:@Date 2018年6月4日 下午4:31:10
 *
 */

class CreateThreadDemo02 implements Runnable{

    /**
     * run方法就是线程需要执行的任务或者执行的代码
     */
    public void run() {
        for(int i = 0; i < 30; i++){
            System.out.println("run:i"+i);
        }
    }
}
public class ThreadDemo02 {
    public static void main(String[] args) {

        //1、创建线程
        CreateThreadDemo01 t1 = new  CreateThreadDemo01();
        Thread thread  = new Thread(t1);
        thread.start();// 2.开始执行线程 注意 开启线程不是调用run方法，而是start方法
        //t1.run();//如果是这样写，代码就会按顺序执行
        for(int i = 0; i < 30; i++){
            System.out.println("main,i="+i);
        }
    }

}

第三种使用匿名内部类创建线程

package com.leeue.thread;
/**
 * 
 * @classDesc: 功能描述:(如何创建多线程)
 * @author:李月
 * @Version:v1.0
 * @createTime:@Date 2018年6月4日 下午4:31:10
 *
 */
public class ThreadDemo02 {

    /**
     * 什么是进程？进程就是正在运行的应用程序，进程是线程的集合。
     * 什么是线程？线程就是一条执行路径，一个独立的执行单元。
     * 什么是多线程？为了提高程序的效率。
     * 创建线程有哪些方式？
     * 1、使用继承Thread类方式
     *    继承Thread类，重写run()方法。
     * 2、使用实现runlable接口方式
     * 3、使用匿名内部类的方式
     * 4、callable
     * 5、使用线程池创建线程，在企业里通常使用线程池来创建
     */
    public static void main(String[] args) {

        //1、创建线程
        Thread thread = new Thread(new Runnable() {

            public void run() {
                for(int i = 0; i < 30; i++){
                    System.out.println("run:i"+i);
                }

            }
        });
        //2、启动线程使用start()方法，而不是run()方法。
        thread.start();
        //t1.run();//如果是这样写，代码就会按顺序执行
        for(int i = 0; i < 30; i++){
            System.out.println("main,i="+i);
        }
    }
}

第五节：常用线程api方法

start() 启动线程
currentThread() 获取当前线程对象
getID() 获取当前线程ID      Thread-编号  该编号从0开始
getName()   获取当前线程名称
sleep(long mill)    休眠线程
Stop（）  停止线程,
常用线程构造函数
Thread（）    分配一个新的 Thread 对象
Thread（String name） 分配一个新的 Thread对象，具有指定的 name正如其名。
Thread（Runable r）   分配一个新的 Thread对象
Thread（Runable r, String name）  分配一个新的 Thread对象

第六节：守护线程和用户线程（非守护线程）

Java中有两种线程：一种是守护线程、一种是用户线程（非守护线程）

用户线程：是指用户自定义创建的线程，主线程停止了，用户线程不会停止

守护线程：当进程不存在，或主线程停止，守护线程也会被停止

用户线程示例图

这里写图片描述

用户线程变守护线程

使用setDaemon(true)方法设置为守护线程

这里写图片描述

Java线程

这里写图片描述

第七节：多线程的运行状态

5种状态：
    新建、准备、运行、休眠(阻塞)、停止



多线程运行状态：

这里写图片描述

第八节：join()方法使用

join();作用就是让其他线程等待这个线程执行完了，再执行。

t1.join();就是让其他进程变为等待，直到当前t1线程执行完毕才继续执行其他的线程。


join ：一个A线程，另一个B线程，A线程调用B这个join方法，
       作用：A等待B线程执行完毕之后(释放我的CPU执行权)，再继续执行，涉及到优先级

例子：创建一个线程，子线程执行完毕后，主线程才能执行？主线程让子线程 先执行完毕后

要把这个放在主线程里

代码：

package com.leeue.thread;
/**
 * 
 * @classDesc: 功能描述:(线程join方法的使用)
 * @author:李月
 * @Version:v1.0
 * @createTime:@Date 2018年6月5日 上午11:20:43
 *
 */
public class ThreadDeom04 {
    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {

            public void run() {
                for (int i = 0; i < 60; i++) {
                    System.out.println("子线程run i:"+i);
                }

            }
        });

        //t1.join();//如果放在这里，就是子线程让主线程了，因为那个调用了join，优先级就低，就要等待
        t1.start();

        try {
            t1.join();//实现是主线程让子线程执行完毕后再执行
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < 30; i++) {
            System.out.println("主线程run i:"+i);
        }
    }
}

作业：1. 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行

实现代码：


package com.leeue.thread.demo;

/**
 * 
 * @classDesc: 功能描述:(1. 现在有T1、T2、T3三个线程， 你怎样保证T2在T1执行完后执行，T3在T2执行完后执行)
 * @author:李月
 * @Version:v1.0
 * @createTime:@Date 2018年6月5日 上午11:30:07
 * T1 > T2
 * T2 > T3
 */
public class ThreadDemo05 {

    public static void main(String[] args) throws Exception {
        final Thread t1 = new Thread(new Runnable() {

            public void run() {
                for (int i = 0; i < 30; i++) {
                    System.out.println("线程T1 run i:" + i);
                }
            }
        });

        t1.start();

        final Thread t2 = new Thread(new Runnable() {

            public void run() {
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                for (int i = 0; i < 30; i++) {
                    System.out.println("线程T2 run i:" + i);
                }
            }
        });

        t2.start();

        Thread t3 = new Thread(new Runnable() {

            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                for (int i = 0; i < 30; i++) {
                    System.out.println("线程T3 run i:" + i);
                }
            }
        });

        t3.start();


    }
}