08_1_多线程的使用

引

如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。

用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。

很多人都对其中的一些概念不够明确，如同步、并发等等，让我们先建立一个数据字典，以免产生误会。

• 多线程：指的是这个程序（一个进程）运行时产生了不止一个线程
• 并行与并发：
  • 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
  • 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力

多线程的实现Thread

package com.itheima.demo01.Thread;

/*
    创建多线程程序的第一种方法:创建Thread类的子类
    java.long.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

    实现步骤:
        1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
        3.创建Thread类的子类对象
        4.调用Thread类中的方法start,开启新线程,执行run方法
            void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法。
            结果是两个线程并发的运行;当前线程(main线程)和另一个线程(创建的新线程,执行去run方法)
            多次启动一个线程是非法的.特别是当线程已经结束执行后,不能再重新启动.
    java程序属于抢占式调度,哪个线程的优先级高,哪个线程优先执行;同一个优先级,随机选择一个执行
 */
public class Demo02Thread {
    public static void main(String[] args) {
        MyThread my = new MyThread();
        my.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main" + " " + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("run" + " " + i);
        }
    }
}

 

获取当前线程的Name 

package com.itheima.demo01.Thread;

/*
    获取线程的名称:
        1.使用Thread类中的方法getName()
            String getName() 返回此线程的名称。
        2.可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称
            static Thread currentThread() 返回对当前正在执行的线程对象的引用。
 */
public class Demo03GetThreadName {
    public static void main(String[] args) {
        MyThread1 mt = new MyThread1();
        mt.start();//Thread-0

        new MyThread1().start();//Thread-1
        System.out.println(Thread.currentThread().getName());

    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
//        String name = getName();
//        System.out.println(name);

        Thread t = Thread.currentThread();
        System.out.println(t);//Thread[Thread-0,5,main]

        String name = t.getName();
        System.out.println(name);//Thread-0

        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

设置线程名

package com.itheima.demo01.Thread;

/*
    设置线程的名称:(了解)
        1.使用Thread类中的方法setName()
            void setName(String name) 将此线程的名称更改为等于参数 name 。
        2.创建一个带参数的构造方法,参数传递线程名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
            Thread(String name) 分配一个新的 Thread对象。
 */
public class Demo04SetThreadName {
    public static void main(String[] args) {
        MyThread2 mt = new MyThread2();
        mt.setName("小强");
        mt.start();

        new MyThread2("旺财").start();
    }
}

class MyThread2 extends Thread {
    public MyThread2(String name) {
        super(name);//把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }

    public MyThread2() {
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

线程的计时等待

package com.itheima.demo01.Thread;

/*

    static void sleep(long millis) 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
    毫秒数结束后,线程继续执行
 */
public class Demo05Sleep {
    public static void main(String[] args) throws InterruptedException {
        //模拟秒表
        for (int i = 0; i <= 60; i++) {
            System.out.println(i);
            //使用Thread类的sleep方法
            Thread.sleep(1000);
        }
    }
}

 多线程的实现Runnable

package com.itheima.demo02.Runnable;

/*
    创建多线程程序的第二种方式,实现Runnable接口
    java.long.Runnable
        Runnable接口应该由那些打算通过某一线程执行其实例的类来实现.类必须定义一个称为run的无参方法
    java.long.Thread类的构造方法
        Thread(Runnable target) 分配一个新的 Thread对象。
        Thread(Runnable target, String name) 分配一个新的 Thread对象。
    实现步骤:
        1.创建一个Runnable接口的实现类
        2.在实现类中重新Runnable接口的run方法,设置线程任务
        3.创建Runnable接口的实现类对象
        4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中start方法,开启新线程执行run方法
    实现Runnable接口创建多线程的好处:
        1.避免了单继承的局限性
            一个类只能继承一个类,(一个人只能有一个亲爹),类继承了Thread类就不能继承其他类了
            实现Runnable接口.还可以继承其他的类,实现其他接口
        2.增强了程序的扩展性,降低了程序的耦合性,(解耦)
            实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离,
            实现类中,重写了run方法,用来设置线程任务
            创建Thread类对象,调用start方法,用来开启新线程
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        RunnableImpl ri = new RunnableImpl();
        Thread t = new Thread(ri, "旺财");
        t.start();

        //匿名内部类
        //1
        new Thread() {
            @Override
            public void run() {
                super.run();
            }
        }.start();
        //2
        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);

        }
    }
}

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);

        }
    }
}

有返回值的多线程实现Callable接口

package com.itheima.demo02_1.Callable;

import java.util.concurrent.*;

public class Demo01Callable {
    public static void main(String[] args){
        ExecutorService es = Executors.newFixedThreadPool(3);

        Future f1 = es.submit(new CallableTest("旺财"));
        Future f2 = es.submit(new CallableTest("金毛"));
        Future f3 = es.submit(new CallableTest("哈哈"));

        try {
            System.out.println(f1.get().toString());
            System.out.println(f2.get().toString());
            System.out.println(f3.get().toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            es.shutdown();
        }
    }
}

class CallableTest implements Callable<String> {
    private String name;

    public CallableTest(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        return name + "运行了";
    }
}

线程的生命周期

线程 生命周期( 状态)
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。
在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞
(Blocked)和死亡(Dead)5 种状态。尤其是当线程启动以后，它不可能一直"霸占"着 CPU 独自
运行，所以 CPU 需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换.

新建状态（NEW ）
当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配
内存，并初始化其成员变量的值.

就绪状态（RUNNABLE ）：
当线程对象调用了 start()方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和
程序计数器，等待调度运行。

运行状 态（RUNNING ）：
如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状
态。

阻塞状态（BLOCKED ）：
阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice，暂时停止运行。
直到线程进入可运行(runnable)状态，才有机会再次获得 cpu timeslice 转到运行(running)状
态。阻塞的情况分三种：
等待阻塞 （ o.wait-> 等待对列 ） ：
运行(running)的线程执行 o.wait()方法，JVM 会把该线程放入等待队列(waitting queue)
中。
同步阻塞 (lock-> 锁池 )
运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线
程放入锁池(lock pool)中。
其他阻塞 (sleep/join)
运行(running)的线程执行 Thread.sleep(long ms)或 t.join()方法，或者发出了 I/O 请求时，
JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O
处理完毕时，线程重新转入可运行(runnable)状态。


线程死亡（DEAD ）
线程会以下面三种方式结束，结束后就是死亡状态。
正常结束
1.  run()或 call()方法执行完成，线程正常结束。
异常结束
2.  线程抛出一个未捕获的 Exception 或 Error。
调用 stop
3.  直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用。