Java多线程基础-优快云博客

本文链接：https://blog.youkuaiyun.com/tf835991342/article/details/114630907

Java基础之多线程

何为程序？何为进程？何为线程？
多线程的四种创建方式
多线程的三种处理线程安全问题（即同步）
多线程的通信
线程的生命周期
多线程的死锁

何为程序？何为进程？何为线程？

何为程序？
	为完成某个任务、用某种语言编写的一组指令的集合。即一段静态的代码，静态对象。
何为进程？
	程序的一次执行过程，或是正在运行的一个程序。是一个动态的过。有它自身的产生、存在和消亡的过程（即生命周期）
	进程是资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。（即独立的堆和方法区）
何为线程？
	进程的进一步细化，是一个程序内部的一条执行路径。
    线程是执行和调度的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销较小。

多线程的四种创建方式

创建多线程方式一：继承于 Thread类

	步骤：
		 1. 创建一个继承于Thread类的子类
		 2. 重写Thread类的run()  --->将此线程执行的操作声明在 run()方法中
		 3. 创建Thread类子类的对象
	     4. 通过此对象调用start()
		        作用： ① 启动当前线程
		              ② 调用当前线程的 run()方法

/**
*	需求：利用多线程输出 1~100之间的所有偶数
*/

//1、创建一个继承于Thread类的子类
class MyThread extends Thread{

    //2、重写 Thread类中得 run()方法
    @Override
    public void run() {
        for (int i=1;i<100;i++){
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
    }
}



public class ThreadTest {
    public static void main(String[] args) {
        //3、创建 Thread类的子类的对象
        MyThread s = new MyThread();

        //4、调用 Thread类中的start()方法：
        s.start();
        
        //问题一：不能通过直接调用run()来启动线程
        //s.run();



        //问题二：再启动一个线程遍历100以内的偶数，需要重新创造一个新的对象，再调用 strat()方法
        MyThread s1 = new MyThread();
        s1.start();

        //以下操作仍然是在main()线程中执行的。
        for (int i=1;i<100;i++){
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+"："+i+"*****main()*****");
            }
        }
    }
}

多线程中常用的方法

	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()：判断当前线程是否存活

/**
 * 线程的优先级：
 * 1、MAX_PRIORITY:10
 *    MIN_PRIORITY：1
 *    NORM_PRIORITY 5  --->默认优先级
 *
 * 2、如何设置优先级和获取优先级：
 * 		getPriority()：获取当线程的优先级
 * 		setPriority()：设置当前线程的优先级
 *
 * 说明：高优先级的线程要抢占低优先级的线程的CPU的执行权，但是从概率上来讲，高优先级的线程高概率的情况下优先被执行，
 *      但并不意味着高优先级的线程执行完以后，低优先级的线程再执行。
 *
 */
public class ThreadMethod {

    public static void main(String[] args) {
        Method m = new Method("Method线程：1");
        //m.setName("Method线程：");

        //给分线程设置优先级
        m.setPriority(Thread.MAX_PRIORITY);
        m.start();


        //给主线程命名
       Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        Thread.currentThread().setName("main线程：");
        for (int i=1;i<100;i++){
            if (i % 2 ==0){

                /*try {   //用来设置每隔 1s执行一次
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                System.out.println(Thread.currentThread().getName()+i);
            }

            /*if (i == 20){
                try {
                    m.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }*/
        }

        //System.out.println(m.isAlive()); //输出线程是否“存活”，存活输出true，反之返回false
    }
}



class Method extends Thread{
    public Method(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i=1;i<100;i++){
            if (i % 2 !=0) {
                /*try {
                    sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                System.out.println(Thread.currentThread().getName()+i);
            }


            /*if (i % 21 ==0){
                yield(); // Thread.currentThread().yield()
                        // 和   this.yield() 的省略版，这里的 this 指代当前类的对象
            }*/
        }
    }
}

创建多线程方式二：实现 Runnable接口

	步骤：
		 1. 创建一个实现类实现接口Runnable
	 	 2. 重写接口中得 run() 方法			--->将此线程执行的操作声明在 run()方法中
		 3. 创建实现类的对象
	 	 4. 将实现类的对象作为参数传给 Thread类的构造器，创建 Thread类的对象
		 5. 通过 Thread类的对象调用 start()

/** 
*  需求：输出 1~100之间的偶数 
*/

public class ThreadTest1 {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MThread m = new MThread();
        
        //4、通过Thread类的构造器创建 参数为实现类对象 的 Thread类的对象
        Thread t1 = new Thread(m);
        t1.setName("Thread1：");

        //5、通过Thread类的对象调用start()
        t1.start();



        Thread t2 = new Thread(m);
        t2.setName("Thread2:");
        t2.start();
    }
}


//1、创建实现类实现接口Runnable
class MThread implements Runnable {

    //2、重写接口中的run()
    @Override
    public void run() {
        for (int i=1;i<100;i++){
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
    }
}

补充：
在开发中，继承Thread类 和 实现Runnable接口两种方式，
优先选择： 实现 Runnable 接口方法。
		原因：1、实现的方式没有单继承的局限性
		     2、实现方式更适合来处理共享数据


Thread 和 Runnable 的联系：
	  1. public class Thread implements Runnable
 	  2. 都要重写 run()，同时把线程要执行的代码声明再run()方法体中

创建方式三：实现接口Callable （JDK 5.0 中新增方式）

	步骤：
		1. 创建实现 Callable接口 的实现类
		2. 实现 call() 方法		--->将此线程执行的操作声明在 call()方法中
		3. 创建 Callable 实现类的对象
		4. 将 Callable 实现类的对象作为参数，通过 FutureTask 类的构造器创建 FutureTask 类的对象
		5. 将 FutureTask 类的对象作为参数，通过 Thread 类的构造器创建 Thread 类的对象，并通过Thread类的对象调用 start() 启动该线程
		6. 获取 Callable 接口中得 call() 的返回值。（可选）

/**
*	需求：输出 1~100之间的所有偶数，并求所有偶数的和
*/
//1、创建实现 Callable接口 的实现类
class NumThread implements Callable {
    private int sum = 0;

    //2、实现 call()方法
    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

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

        //3、创建 Callable 实现类的对象
        NumThread n = new NumThread();

        //4、将Callable 实现类的对象作为参数，通过 FutureTask类的构造器创建 FutureTask 的对象
        FutureTask futureTask = new FutureTask(n);


        //5、将 FutureTask类 的对象作为参数，通过Thread类的构造器创建 Thread类的对象，并调用 start()启动该线程
        new Thread(futureTask).start();


        try {
            //6、获取 Callable实现类 中得 call() 的返回值
            //此处的 get()方法的返回值即为
            //FutureTask构造器参数 Callable 实现类的对象中得 call()方法的返回值
            Object o = futureTask.get();
            System.out.println("1-100之间的所有偶数的和为：" + o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

	实现 Callable 接口 比实现 Runnable 接口强大：
		1、call() 可以有返回值
		2、call() 可以抛出异常，被外面的操作捕获，获取异常信息
		3、Callable 是支持泛型的。

创建方式四：线程池（JDK 5.0 中新增方式）


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

        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor sevice1 = (ThreadPoolExecutor) service;



        //执行指定的线程。需要提供实现 Runnable接口或者 Callable接口 的实现类对象
        //适合使用于Runnable
        service.execute(new NumberThread());
        //适合使用于Runnable
        service.execute(new NumberThread2());



        //设置线程池的属性
        //System.out.println(service.getClass());//获取当前对象所属的类
        sevice1.setCorePoolSize(15);	//设置线程池的大小



        //service.submit(Callable callable ) //适合使用于Callable

        //关闭线程池
        service.shutdown();
    }
}


class NumberThread implements Runnable {

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

class NumberThread2 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}

使用线程池的好处

	1. 提高响应速度（减少了创建新线程的时间）
	2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
	3. 便于线程管理：
			corePoolSize：核心池的大小
			maxmumPoolsize：最大线程数
			heepAliveTime：线程没有任务时，最多保持多长时间后会终止

多线程的三种处理线程安全问题（即同步）

处理方式一：同步代码块

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

/** 处理方式一：同步代码块
 *
 *      synchronized(同步监视器){
 *          //需要被同步的代码
 *      }
 *
 *      说明：1、操作共享数据的代码，即为需要被同步的代码     ---->不能包含代码多了，也不能包含少了
 *           2、共享数据：多个线程共同操作的变量，比如：ticket 就是共享数据
 *           3、同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 *
 *              要求：多个线程必须要共用同一把锁
 *
 *           4、补充：在实现 Runnable接口创建多线程方式中，可以考虑使用 this 充当同步监视器
 *
 *
 * 			5、同步的方式，解决了线程的安全问题。 ---好处
 *    		   操作同步代码块时，只能一个线程操作，其他线程等待，相当于一个单线程，效率低。 ---坏处
 *	
 *		
 *	
 *	需求：创建三个窗口买票，总票数为 100。
 *		
 * @author Herz
 * @date 2021/3/8 15:30
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w1 = new Window1();

        Thread t1 = new Thread(w1);
        t1.setName("窗口 1");
        t1.start();

        Thread t2 = new Thread(w1);
        t2.setName("窗口 2");
        t2.start();

        Thread t3 = new Thread(w1);
        t3.setName("窗口 3");
        t3.start();
    }
}


class Window1 implements Runnable{

    private  int ticket = 100;

    //Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (this) {//这里的this 指代的是当前类的对象也就是 w 对象
                                    //方式二： synchronized (obj)
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

处理方式二：同步方法

用 synchronized 修饰该操作方法

说明：
	1、同步方法任然涉及到同步监视器，只是不用显示声明
    2、非静态同步方法中，同步监视器是：this
	   静态同步方法中，同步监视器是：当前类本身

/**
*	处理方式二：使用同步方法解决 实现 Runnable接口创建多线程的方式的线程安全问题
*				（解决继承Thread类创建多线程方式的线程安全问题类似）
*
* 	例：创建三个窗口售票，总票数为100张
*/
public class WindowTest11 {
    public static void main(String[] args) {
        Window11 w = new Window11();

        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();
    }
}


class Window11 implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private synchronized void show(){  //同步监视器：this
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
            ticket--;
        }
    }
}

处理方式三：Lock锁（JDK 5.0 新增方式）

/**
* 	需求：创建三个窗口售票，总票数为100张
*/
class Window implements Runnable {

    private int ticket = 100;

    //实例化 ReentrantLock 类
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {

                //调用 lock()
                lock.lock();

                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}


public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        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();
    }
}

面试题 synchronized 和 Lock锁的异同：

		同：二者都可以解决线程安全问题
		异：synchronized 在执行完相应的同步代码后，自动的释放同步监视器，
		   Lock 需要手动的启动同步（lock()），同时结束的时候需要手动释放（unlock()）。

多线程的通信

涉及到的三个方法：

	wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
	notify()：一旦执行此方法，就会唤醒被wait()的一个线程。如果有多个线程，就唤醒优先级高的那个。
	notifyAll()：一旦执行此方法，就会唤醒所有被wait()的线程。

说明：

	1、wait()、notify()、notifyAll() 三个方法必须使用在同步代码块或同步方法中。
	2、wait()、notify()、notifyAll() 三个方法的调用者必须是同步代码块或同步方法中得同步监视器。
	   否则，会出现 IllegalMonitorStateException 异常。

/**
 *
 * 线程间的通信练习：
 *      使两个线程打印1-100，交替打印
 *
 * @author Herz
 * @date 2021/3/9 21:32
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Communicate c = new Communicate();

        //实例化两个线程
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);

        t1.setName("线程 1");
        t2.setName("线程 2");

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


class Communicate implements Runnable{

    private int num = 1;
    //private Object obj = new Object();

    @Override
    public void run() {

        while (true){
            //synchronized (obj) {
            synchronized (this){
                this.notify(); //唤醒另外一个线程

                if (num <= 100) {
                    System.out.println(Thread.currentThread().getName() + "：" + num);
                    num++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

线程的生命周期

多线程的死锁

/**
 *
 * 演示线程的死锁问题：
 *
 *    1、死锁的理解：不同的线程分别占用对方需要的资源不放弃，
 *      都在等待对方放弃自己需要的同步资源，就形成了死锁。
 *
 *
 *    2、说明：
 *       1）出现死锁后，不会出现异常，不会出现提示，只是所有的线程处于阻塞状态，无法继续
 *       2）使用同步时，避免死锁。
 *
 * @author Herz
 * @date 2021/3/9 15:10
 */
public class DeadlockTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();


        new Thread(){
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }

            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}