目录

• 并发编程（一）多线程基础
• 1、进程和线程的概念
• 2、为什么要使用多线程
• 3、多线程使用的场景
• 4、多线程创建方式
  • 4.1、继承Thread类
  • 4.2、实现Runable接口
  • 4.3、匿名内部类
  • 4.4、线程池（后面细说）
• 5、线程的声生命周期
  • 5.1、新建
  • 5.2、就绪
  • 5.3、运行
  • 5.4、阻塞
  • 5.5、死亡
• 6、守护线程
• 7、join方法

并发编程（一）多线程基础

1、进程和线程的概念

• 进程：一个应用程序，在进程中会有N多个线程，进程是所有线程的集合。
• 线程：一条执行路径。

2、为什么要使用多线程

可以提高程序运行的效率。

3、多线程使用的场景

1. 给用户发送短信，防止调用短信接口耗时过长
2. 打包图片压缩包

4、多线程创建方式

4.1、继承Thread类

package com.fly.thread_demo.demo_1;

/**
 * 线程创建方式一： 继承Thread类 重写run方法
 */
public class ThreadDemo_1 extends Thread{
    @Override
    public void run() {
        System.out.println("子线程开始");
        for (int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
        }
        System.out.println("子线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t1 = new ThreadDemo_1();
        t1.start();
        System.out.println("主线程结束");
    }
}

4.2、实现Runable接口

package com.fly.thread_demo.demo_1;
/**
 * 线程创建方式二： 实现Runnable接口
 */
public class ThreadDemo_2 implements Runnable{
    @Override
    public void run() {
        System.out.println("子线程开始");
        for (int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
        }
        System.out.println("子线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        //在Thread构造方法中  接受一个Runnable接口
        Thread t2 = new Thread(new ThreadDemo_2());
        t2.start();
        System.out.println("主线程结束");
    }
}

4.3、匿名内部类

package com.fly.thread_demo.demo_1;

/**
 * 线程创建方式三： 匿名类部类
 */
public class ThreadDemo_3 {

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程开始");
                for (int i = 0; i < 10; i++) {
                    System.out.println("i = " + i);
                }
                System.out.println("子线程结束");
            }
        });
        t3.start();
        System.out.println("主线程结束");
    }
}

4.4、线程池（后面细说）

5、线程的声生命周期

5.1、新建

? new Thread();

5.2、就绪

? 调用start方法后，执行run方法前，等待cpu分配资源

5.3、运行

? 执行run方法

5.4、阻塞

1. 调用sleep方法
2. 调用阻塞式IO
3. 调用wait方法

5.5、死亡

1. run方法执行完毕
2. 抛出异常
3. 调用stop方法 （容易造成死锁，不推荐使用）

6、守护线程

package com.fly.thread_demo.demo_1;

/**
 * 非守护线程：主线程死亡，不影响  非守护线程
 * 守护线程：主线程死亡，守护线程同时死亡
 */
public class ThreadDemo_4 implements Runnable{
    @Override
    public void run() {
        System.out.println("子线程开始");
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("i = " + i);
        }
        System.out.println("子线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t4 = new Thread(new ThreadDemo_4());
        t4.setDaemon(true);//把t4设置为守护线程 (可以对比  设置和设置的区别)
        t4.start();
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束");
    }
}

7、join方法

package com.fly.thread_demo.demo_1;

/**
 *  join :
 *      1) 线程同步，是并行的线程编程串行，在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行
 *      2) 在start方法调用之后调用
 *      3) 实现原理：调用线程的wait方法来达到同步的目的
 */
public class ThreadDemo_5 {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 30; i++) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("子线程i = " + i);
                }
            }
        });

        t1.start();
        try {
            //(可以对比  设置和设置打印结果的区别)
            t1.join(); //在主线程中调用t1的join方法   表示让t1先执行完毕再执行主线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主i = " + i);
        }
    }
}

package com.fly.thread_demo.demo_1;

/**
 * 面试题  现在有3个线程 t1 ,t2,t3   如何让t1 执行完毕 再执行 t2  t2执行完毕再执行t3
 */
public class ThreadDemo_6 {

    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("t1:i = " + i);
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t1.join();//t2 中 调用 t1.join() ：让t1执行完毕执行t2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println("t2:i = " + i);
                }
            }
        });
        t2.start();

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t2.join();//t3中 调用 t2.join() ：让t2执行完毕执行t3
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println("t3:i = " + i);
                }
            }
        });
        t3.start();
    }
}

原文地址：https://www.cnblogs.com/bigfly277/p/10200428.html