分配一个新的线程对象。public Thread(String name)

分配一个指定名字的新的线程对象public Thread(Runnable target)

分配一个带有指定目标新的线程对象public Thread(Runnable target,String name)

分配一个带有指定目标新的线程对象并指定名字1.3.2、常用方法public String getName() :获取当前线程名称。public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法public void run() :此线程要执行的任务在此处定义代码。public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。public static Thread currentThread() :返回对当前正在执行的线程对象的引用。2、实现Runnable接口2.1、优势：避免单继承的局限性

一个类继承了Thread类就不能继承其他的类

一个类实现了Runnable接口,还可以继续继承别的类,实现其他的接口增强了程序的扩展性,降低程序的耦合度

使用Runnable接口把设置线程任务和开启线程相分离

实现类当中,重写run方法,设置线程任务

创建Thread类对象,调用 start方法,开启新线程2.2、实现步骤创建一个RunnableImpl类实现Runnable接口重写Runnable接口中的run方法,设置线程任务创建Runnable接口的实现类RunnableImpl的对象创建Thread类对象,构造方法中传递Runnable接口的实现类RunnableImpl的对象调用Thread类中的start方法,开启新的线程,执行run方法2.3、实现实例：

/** * 实现Runnable 接口 */public class TestRunnable implements Runnable {    @Override    public void run() {        // run的方法体        for (int i = 0; i < 2000; i++) {            System.out.println("我在刷抖音!" + i);        }    }     public static void main(String[] args) {        Thread thread = new Thread(new TestRunnable());        thread.start();         for (int i = 0; i < 2000; i++) {            System.out.println("我在上厕所!" + i);        }    }}

/** * 实现Callable 接口 * * 好处: 1.可以定义返回值类型 2、可以抛出异常 */public class TestCallable implements Callable<Boolean> {     String name = null;     public TestCallable(String name){        this.name = name;    }     @Override    public Boolean call() throws Exception {        // run的方法体        for (int i = 1; i <= 20; i++) {            System.out.println(name + i);        }         return true;    }     public static void main(String[] args) throws ExecutionException, InterruptedException {        // 1.创建线程        TestCallable t1 = new TestCallable("睡觉！");        TestCallable t2 = new TestCallable("水饺");         // 2.创建执行服务        ExecutorService ser = Executors.newFixedThreadPool(2);         // 3.提交执行        Future<Boolean> r1 = ser.submit(t1);        Future<Boolean> r2 = ser.submit(t2);         // 4.获取结果        Boolean res1 = r1.get();        Boolean res2 = r2.get();         System.out.println(res1);        System.out.println(res2);         // 5.关闭服务        ser.shutdown();    }}

后续章节补充

三、线程方法1、守护线程

线程分为守护线程和用户线程，守护线程的作用是为其他线程运行提供便利服务,用户线程如果全部退出执行,守护线程也会随之关闭,守护线程最经典的 例子GC(垃圾回收器)。

/** * 守护线程*/public class TestDaemon {    public static void main(String[] args) {        Mom mom = new Mom();        Thread thread = new Thread(mom);        thread.setDaemon(true); // 开启守护线程        thread.start();         new Thread(new Me()).start();    }}  class Mom implements Runnable {    @Override    public void run() {        while (true){            System.out.println("妈妈监视我写作业！！");        }    }} class Me implements Runnable {     @Override    public void run() {        for (int i = 0; i < 300; i++) {            System.out.println("我在写作业!!");        }        System.out.println("===》我作业写完了！！");    }}

JOIN合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。

/** * 线程插队 JOIN() */public class TestJoin implements Runnable{    @Override    public void run() {        for (int i = 0; i < 200; i++) {            System.out.println("Vip来了....." + i);        }    }     public static void main(String[] args) throws InterruptedException {        TestJoin testJoin = new TestJoin();        Thread thread = new Thread(testJoin);        thread.start();         for (int i = 0; i < 1000; i++) {            if (i == 500){                thread.join(); // 插队            }            System.out.println("main" +i);        }    }}

线程的优先级越高意味着获得调度的概率就高,但并不代表优先级低的线程就不会被调度,这都是看CPU心情的！！

/** * 线程优先级 * 线程默认的优先级 5  最大是 10  最小 1 * 线程设置优先级,要在线程启动前设置 */public class TestPriority implements Runnable {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "====>" + Thread.currentThread().getPriority());    }     public static void main(String[] args) {        // 主线程的默认优先级        System.out.println(Thread.currentThread().getName() + "====>" + Thread.currentThread().getPriority());         TestPriority testPriority = new TestPriority();        Thread t1 = new Thread(testPriority, "t1");        Thread t2 = new Thread(testPriority, "t2");        Thread t3 = new Thread(testPriority, "t3");         // 设置优先级3        t1.setPriority(3);        t1.start();         // 设置最大优先级        t2.setPriority(Thread.MAX_PRIORITY);        t2.start();         // 设置最小优先级        t3.setPriority(Thread.MIN_PRIORITY);        t3.start();    }}

案例：

/** * 线程睡眠 : 更容易发现多线程下方法存在的问题 (放大问题的发生性) */public class TestSleep implements Runnable{     int ticket = 10;     @Override    public void run() {        while (true){            if (ticket <= 0 ){                break;            }             try {                Thread.sleep(200);            } catch (InterruptedException e) {                e.printStackTrace();            }             System.out.println(Thread.currentThread().getName() + "抢到了第" + ticket-- + "票");        }    }     public static void main(String[] args) {        TestSleep ticket = new TestSleep();         // 模拟三条线程同时抢票        new Thread(ticket,"小明").start();        new Thread(ticket,"小强").start();        new Thread(ticket,"黄牛").start();    }}

线程的五种状态

Java中对于线程总共设定了5个状态，分别为：新建状态、就绪状态、运行状态、阻塞状态、死亡状态。

新建状态（New）：顾名思义就是我们通过new Thread() 创建了线程，但是还并未启动线程。就绪状态（Runnable）：当其他线程调用start 方法启动该线程的时候，线程首先会进入准备就绪状态也被称为“可运行状态”，随时等待线程调度程序获取CPU的执行时间（即CPU时间片）。运行状态（Running）：线程调度程序一旦获取到了CPU的执行时间线程就进入运行状态并执行线程的程序代码。阻塞状态（Blocked）：阻塞状态是指线程因为某种原因放弃了CPU使用权，让出了CPU的执行时间。直到线程进入“可运行状态”，才有机会再次获得CPU执行时间 转到“运行状态”。死亡状态（Dead）：当线程执行代码运行完之后或者因为异常退出了run方法，那么该线程都会结束其生命周期。

导致线程阻塞主要有三种情况：

①无限等待：当调用了没有时间参数的Object.wait()、Thread.join()、LockSupport.park()等方法，当前线程就会处于无限等待状态，这种等待需要其他线程显示的唤醒才能重新获取CPU执行时间进入运行状态，例如：调用Object.notify()可以唤醒调用Object.wait()阻塞的线程。②限时等待：当调用了Thread.sleep()、Object.wait(timeout)、Thread.join(millis)、LockSupport.parkNanos(nanos)、LockSupport.parkUnit(deadline)等方法，当前线程也会处于等待状态，但是无须等待被其他线程显示的唤醒，在一定时间后它们会由系统自动唤醒。③同步等待：运行的线程在获取对象的synchronized同步锁时，若该同步锁被别的线程占用则获取失败，JVM会把该线程放入锁池(lock pool)中，它会进入同步阻塞状态。等占用同步锁的线程释放了同步锁之后，线程就会再次尝试获取同步锁，如果获取成功则进入运行状态。