进程是一个应用程序，线程是一个进程中的执行场景/执行单元。一个进程可以启动多个线程。在java语言中对于两个线程A和B，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。在使用了多线程机制之后，main（）方法结束了，只是主线程结束了，主栈空了，但其他线程不一定结束，其他栈（线程）可能还在压栈弹栈。

1、java实现线程

java语言支持多线程机制。并且java已经实现了多线程（java.lang.Thread类和java.lang.Runnable接口)

第一种实现方式（继承java.lang.Thread类并重写run方法)

public class Thread_01 extends Thread {

    @Override

    public void run() {

        super.run();

        System.out.println("第一个线程");

    }

    public static void main(String[] args) {

        Thread thread=new Thread(new Thread_01(),"first_thread");  //创建线程对象

        thread.start();  //启动线程  start方法使线程处于就绪队列，等待CPU调用

    }

}

第二种实现方式（实现java.lang.Runnable接口并实现run方法）

public class Thread_02 implements Runnable {

    @Override

    public void run() {

        System.out.println("第一个线程");

    }

    public static void main(String[] args) {

        Thread thread=new Thread(new Thread_01(),"first_thread");  //创建线程对象

        thread.start();  //启动线程  start方法使线程处于就绪队列，等待CPU调用

    }

}

通常使用第二种方法，因为一个类实现了接口还可以继承其他类

注意：start方法和run方法的区别！！！

run方法不会启动线程。

start方法的作用是：启动一个线程，在JVM中为线程开辟一个新的栈空间。之后start方法就结束了。线程启动成功并进入排队等待序列。等到被CPU调用到，就会自动调用run方法。

2、线程的生命周期

3、线程常用的方法

3.1、sleep()

public static native void sleep(long millis) throws InterruptedException;

作用：让线程进入休眠，进入“阻塞状态”。放弃占有CPU时间片，让其他线程使用。

public class Thread_03 {

    public static void main(String[] args) throws InterruptedException {

        Thread thread=new Thread(new Thread_03_1(),"Thread_03_1");

        thread.start();

        int count=1; //计数器

        while(true){

            System.out.println("Thread_03_1线程沉睡了"+count+++"秒");

            Thread.sleep(1000);

            if(count>5){

                break;

            }

        }

    }

}

class Thread_03_1 implements Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(1000*5);    //让线程沉睡（等待） 5秒

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(Thread.currentThread().getName());

    }

}

3.2、interrupt方法

interrupt方法可以中断线程的睡眠，依靠了java异常处理机制

public class Thread_03 {

    public static void main(String[] args) throws InterruptedException {

        Thread thread=new Thread(new Thread_03_1(),"Thread_03_1");

        thread.start();

        int count=1; //计数器

        while(true){

            System.out.println("Thread_03_1线程沉睡了"+count+++"秒");

            Thread.sleep(1000);

            if(count==3){

                System.out.println("打断Thread_03_1睡眠");

                thread.interrupt();

                break;

            }

        }

    }

}

class Thread_03_1 implements Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(1000*5);    //让线程沉睡（等待） 5秒

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(Thread.currentThread().getName()+"醒了");

    }

}

线程Thread_03_1原计划沉睡5秒，在它睡到3秒时，使用interrupt方法打断其睡眠。

3.3、stop方法

stop方法可以强制终止一个线程的执行。不过这种方式容易丢失数据。因为这种方式会直接杀死线程，线程没有保存的数据会丢失。所以不建议使用

public class Thread_04 {

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new Thread_04_1(), "Thread_03_1");

        thread.start();

        //线程Thread_03_1执行5秒后，强制结束线程Thread_03_1

        Thread.sleep(1000*6);

        System.out.println("强制终止线程Thread_03_1");

        thread.stop();    //强制终止线程

    }

}

    class Thread_04_1 implements Runnable{

        @Override

        public void run() {

           for(int i=1;i<1000;i++) {

               try {

                   Thread.sleep(1000);

               } catch (InterruptedException e) {

                   e.printStackTrace();

               }

               System.out.println(Thread.currentThread()+"-->"+i+"秒");

           }

        }

    }

建议使用如下方法结束一个线程：在线程类中增加一个布尔类型的变量run，通过改变run的值，来控制线程运行/停止状态。

public class Thread_05 {

    public static void main(String[] args) throws InterruptedException {

        Thread_05_1 t=new Thread_05_1();

        Thread thread = new Thread(t, "Thread_05_1");

        thread.start();

        //等候5秒之后，终止该线程

        Thread.sleep(1000*5);

        t.run=false;

        System.out.println(thread.getName()+"线程已暂停");

        }

    }

    class Thread_05_1 implements Runnable{

        boolean run=true;                      //通过引入一个布尔类型的变量，来标记该线程的状态（运行/停止）

        @Override

        public void run() {

                for (int i = 1; i < 1000; i++) {

                    if (run) {

                        System.out.println(Thread.currentThread().getName() + "-->" + i + "秒");

                        try {

                            Thread.sleep(1000);

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }else{

                        /**

                         * return就表示该线程结束了

                         * 如果有什么需要保存的，可以写在return之前

                         */

                        return;

                    }

                }

            }

        }

4、线程调度

4.1、常见的线程调度模型

抢占式调度模型、均分式调度模型

4.2、java中提供的线程调度方法

void setPriority(int newPriority)       //设置线程优先级

int getPriority()       //获取线程优先级

最低优先级：1 默认优先级：5 最高优先级：10

优先级高的线程抢占的CPU时间片就多一些，处于运行状态的时间片就多一些

public class Thread_06 {

    public static void main(String[] args) {

        Thread_06_1 t61=new Thread_06_1();

        Thread_06_2 t62=new Thread_06_2();

        Thread_06_3 t63=new Thread_06_3();

        Thread thread1=new Thread(t61,"Thread_06_1");

        Thread thread2=new Thread(t62,"Thread_06_2");

        Thread thread3=new Thread(t63,"Thread_06_3");

        //设置线程优先级

        thread1.setPriority(1); thread2.setPriority(2); thread3.setPriority(10);

        thread1.start(); thread2.start(); thread3.start();

        System.out.println("主线程优先级为："+Thread.currentThread().getPriority());

        for(int i=0;i<1000;i++){

            System.out.println(Thread.currentThread().getName()+"-->"+i);

        }

    }

}

    class Thread_06_1 implements Runnable{

        @Override

        public void run() {

            System.out.println(Thread.currentThread().getName()+"优先级为："+Thread.currentThread().getPriority());

            for(int i=0;i<1000;i++){

                System.out.println(Thread.currentThread().getName()+"-->"+i);

            }

        }

    }

    class Thread_06_2 implements Runnable{

        @Override

        public void run() {

            System.out.println(Thread.currentThread().getName()+"优先级为："+Thread.currentThread().getPriority());

            for(int i=0;i<1000;i++){

                System.out.println(Thread.currentThread().getName()+"-->"+i);

            }

        }

    }

    class Thread_06_3 implements Runnable{

        @Override

        public void run() {

            System.out.println(Thread.currentThread().getName()+"优先级为："+Thread.currentThread().getPriority());

            for(int i=0;i<1000;i++){

                System.out.println(Thread.currentThread().getName()+"-->"+i);

            }

        }

    }

4.3、线程让步

yield方法：使当前线程暂停，回到就绪状态，让给其他线程

public static native void yield();

public class Thread_07 {

    public static void main(String[] args) {

        Thread_07_1 tt=new Thread_07_1();

        Thread thread=new Thread(tt,"Thread_07_1");

        thread.start();

        for(int i=0;i<100;i++){

            System.out.println(Thread.currentThread().getName()+"-->"+i);

        }

    }

}

    class Thread_07_1 implements Runnable{

        @Override

        public void run() {

            for(int i=0;i<100;i++){

                if(i%10==0){

                    System.out.println(Thread.currentThread().getName()+"暂停了一下");

                    Thread.yield();   //让当前线程暂停一下

                }

                System.out.println(Thread.currentThread().getName()+"-->"+i);

            }

        }

    }

4.4、线程合并

join方法可以使得在t.join()中让CPU优先执行完t。将t合并到当前线程中，使当前线程受阻，t线程执行直到结束。

public class Thread_08 {

    public static void main(String[] args) throws InterruptedException {

        Thread_08_1 thread_08_1=new Thread_08_1();

        Thread_08_2 thread_08_2=new Thread_08_2();

        Thread thread=new Thread(thread_08_1,"Thread_08_1");

        Thread thread1=new Thread(thread_08_2,"Thread_08_2");

        thread.start();

        //合并线程

        thread.join();   //t合并到当前线程中，当前线程受阻塞，t线程执行直到结束

        thread1.start();

        thread1.join();

        //Thread.currentThread().join();

        System.out.println("main over");

    }

}

class Thread_08_1 implements Runnable{

    @Override

    public void run() {

        for(int i=0;i<3;i++){

            System.out.println(Thread.currentThread().getName()+"-->"+i);

        }

    }

}

class Thread_08_2 implements Runnable{

    @Override

    public void run() {

        for(int i=0;i<3;i++){

            System.out.println(Thread.currentThread().getName()+"-->"+i);

        }

    }

}

join(）的底层实现代码。

public final void join() throws InterruptedException {

        join(0);

    } 

public final synchronized void join(long millis)

    throws InterruptedException {

        long base = System.currentTimeMillis();

        long now = 0;

        if (millis < 0) {

            throw new IllegalArgumentException("timeout value is negative");

        }

        if (millis == 0) {

            while (isAlive()) {

                wait(0);

            }

        } else {

            while (isAlive()) {

                long delay = millis - now;

                if (delay <= 0) {

                    break;

                }

                wait(delay);

                now = System.currentTimeMillis() - base;

            }

        }

    }

join()是在底层调用了wait方法，当主线程调用了thread.join()之后，主线程进入此方法，调用join()方法中的wait(0)方法，wait(0)表示无限等待直到被notify。即主线程会无限等待thread线程执行完成。

public final void wait(long timeout, int nanos) throws InterruptedException {

        if (timeout < 0) {

            throw new IllegalArgumentException("timeout value is negative");

        }

        if (nanos < 0 || nanos > 999999) {

            throw new IllegalArgumentException(

                                "nanosecond timeout value out of range");

        }

        if (nanos > 0) {

            timeout++;

        }

        wait(timeout);

    }

4.5、线程安全

数据在多线程并发的环境下会存在安全问题。例如如果多个用户想要修改某个共享的数据，就会引发线程安全问题。因此需要引入线程同步机制（即线程排队执行，不能并发）

4.5.1、线程同步的实现

java里面通过关键字synchronized给线程加锁。线程会获取锁，并独占cpu,只有当线程释放了锁之后，其余线程拿到锁之后才能运行。

当一个线程在运行状态时遇到synchronized关键字，该线程就会放弃占有的cpu时间片，在锁池里面找共享对象的对象锁。

一个线程同步synchronized的例子——模拟ATM机取款

Account类

package ATM;

/*

银行账户，使用线程同步机制，解决线程安全问题

 */

public class Account {

    private String accountName;  //账户名

    private double remain;  //余额

    Object obj=new Object();

    public Account(String accountName, int remain) {

        this.accountName = accountName;

        this.remain = remain;

    }

    public String getAccountName() {

        return accountName;

    }

    public void setAccountName(String accountName) {

        this.accountName = accountName;

    }

    public double getRemain() {

        return remain;

    }

    public void setRemain(double remain) {

        this.remain = remain;

    }

    //取款方法

    public void withdraw(double money) {

        //synchronized (obj){   //obj是一个全局变量，实例一次Account创建一个obj对象，是可以被共享的

        /*Object obj1=new Object();

        synchronized (obj1){*/    //obj1是一个局部变量，每调用一次run方法则会创建一个obj1对象，所以obj1不是共享对象

        //synchronized (null){    //报错：空指针

        //synchronized ("abc"){    //"abc"在字符串常量池当中，会让所有的线程都同步

        synchronized (this){

            double before = this.getRemain();  //取款之前的余额

            double after = before - money;    //取款之后的余额

            try{

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            this.setRemain(after);     //更新余额

        }

    }

}

AccountThread类

package ATM;

public class AccountThread extends Thread {

    //两个线程必须共享同一个账户对象

    private Account act;

    private double money;  //取款金额

    //通过构造方法传递过来构造对象

    public AccountThread(Account act,double money) {

        this.act = act;

        this.money=money;

    }

    @Override

    public void run() {  //run方法执行表示取款操作

       act.withdraw(money);

        System.out.println(Thread.currentThread().getName()+"在账户"+

                act.getAccountName()+"取款"+money+"之后余额为："+act.getRemain());

    }

}

启动类：Test类

package ATM;

public class Test {

    public static void main(String[] args) {

        Account act=new Account("act001",10000);  //创建账户对象

        //创建两个线程，对同一账户取款

        Thread threadA=new AccountThread(act,5000);

        Thread threadB=new AccountThread(act,3000);

        threadA.setName("小明");

        threadB.setName("小华");

        threadA.start();

        threadB.start();

    }

}

结果：

 //synchronized可以用在实例方法上，此时锁是this

public synchronized void withdraw(double money) {

        double before = this.getRemain();  //取款之前的余额

        double after = before - money;    //取款之后的余额

        try {

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        this.setRemain(after);     //更新余额

    }

}

可以在实例方法上使用synchronized，synchronized出现在实例方法上，锁一定是this，不能是其他的对象了。所以这种方式不灵活。

另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低。所以这种方式不常用。

4.5.2、java中的线程安全性

java中有三大变量：1、实例变量（在堆中） 2、静态变量（在方法中） 3、局部变量（在栈中）

局部变量不会有线程安全问题，因为局部变量不共享，局部变量在栈中，一个线程一个栈。

常量不会有线程安全问题，因为常量不会被改变。

实例变量在堆中，堆只有1个。静态变量在方法区中，方法区只有1个。由于堆和方法区都是多线程可共享的，所以实例变量和静态变量可能存在线程安全问题。

ArrayList、HashMap 、HashSet 是非线程安全的

Vector、Hashtable 是线程安全的

4.5.3、synchronized总结

synchronized有三种写法：

第一种：同步代码块（灵活）

synchronized(线程共享对象){

同步代码块;

}

第二种：在实例方法上使用 synchronized

表示共享对象一定是this，并且同步代码块是整个方法体。

第三种：在静态方法上使用 synchronized

表示找类锁。

类锁永远只有1把（就算创建了100个对象，那类锁也只有1把）

对象锁：1个对象1把锁，100个对象100把锁。类锁：100个对象，也可能只是1把类锁。

package Synchronized;

//Q：doOther方法执行的时候需要等待doSome方法的结束吗？

//A：需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把

public class Exam01 {

    public static void main(String[] args) throws InterruptedException {

        MyClass mc1 = new MyClass();

        MyClass mc2 = new MyClass();

        Thread t1 = new Mythread(mc1);

        Thread t2 = new Mythread(mc2);

        t1.setName("t1");

        t2.setName("t2");

        t1.start();

        Thread.sleep(1000);

        t2.start();

    }

}

class Mythread extends Thread {

    private MyClass mc;

    public Mythread(MyClass mc) {

        this.mc = mc;

    }

    @Override

    public void run() {

        super.run();

        if (Thread.currentThread().getName().equals("t1")) {

            try {

                mc.doSome();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        if (Thread.currentThread().getName().equals("t2")) {

            mc.doOther();

        }

    }

}

class MyClass {

    //synchronized出现在静态方法上是走 类锁

    public synchronized static void doSome() throws InterruptedException {

        System.out.println("doSome begin");

        Thread.sleep(1000 * 5);

        System.out.println("doSome over");

    }

    public synchronized static void doOther() {

        System.out.println("doOther begin");

        System.out.println("doOther over");

    }

}

4.5.4、死锁

一个简单的死锁实现的例子

package Thread;

/*

实现一个死锁，

t1中obj1锁上后就睡了，t2中obj2锁上后就睡了。

t1想要释放obj1锁，就必须请求到obj2锁

t2想要释放obj2锁，就必须请求到obj1锁

t1与t2互相请求锁，但彼此都无法释放锁，所以形成了死锁

 */

public class Dead_lock {

    public static void main(String[] args) {

        Object obj1 = new Object();

        Object obj2 = new Object();

        //t1,t2两个线程共享o1,o2

        Thread t1 = new MyThread_1(obj1, obj2);

        Thread t2 = new MyThread_2(obj1, obj2);

        t1.start();

        t2.start();

    }

}

class MyThread_1 extends Thread {

    Object obj1 = new Object();

    Object obj2 = new Object();

    public MyThread_1(Object obj1, Object obj2) {

        this.obj1 = obj1;

        this.obj2 = obj2;

    }

    @Override

    public void run() {

        synchronized (obj1) {

            try {

                Thread.sleep(1000 * 3);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized (obj2) {

            }

        }

    }

}

class MyThread_2 extends Thread {

    Object obj1 = new Object();

    Object obj2 = new Object();

    public MyThread_2(Object obj1, Object obj2) {

        this.obj1 = obj1;

        this.obj2 = obj2;

    }

    @Override

    public void run() {

        synchronized (obj2) {

            try {

                Thread.sleep(1000 * 3);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized (obj1) {

            }

        }

    }

}

注：synchronized在开发中最好不要嵌套使用，一不小心就可能导致死锁现象发生

4.6、守护线程

java语言中线程可分为两大类：

一类是：用户线程例如：main方法主线程

一类是：守护线程（后台线程）例如java垃圾回收线程

4.6.1、守护线程的特点

一般守护线程是一个死循环，所有用户线程只要结束，守护线程自动结束。

守护线程一般会用在一些定时任务，例如每天0点系统自动备份需要用到定时器，我们可以将定时器设置为守护线程一直在那里看着。每到0点就备份一次。所有的用户线程如果结束了，守护线程就自动退出。

4.6.2、一个简单的守护线程的例子

package Thread;

/**

 * 用户线程备份数据，守护线程守护。

 */

public class GuardThread {

    public static void main(String[] args) {

        Thread thread = new BakDataThread();

        thread.setName("备份数据的线程");

        //启动线程之前，将线程设置为守护线程

        thread.setDaemon(true);

        thread.start();

        for (int i = 0; i < 5; i++) {

            System.out.println(Thread.currentThread().getName() + "--->" + i);

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

class BakDataThread extends Thread {

    @Override

    public void run() {

        int i = 0;

        //即使是死循环，但由于该线程是守护者。当用户线程结束，守护线程自动终止

        while (true) {

            System.out.println(Thread.currentThread().getName() + "--->" + i++);

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

5、定时任务

5.1、实现一个定时器

package Thread;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

public class TimerTest {

    public static void main(String[] args) throws ParseException {

        //创建定时器对象

        Timer timer = new Timer();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date firstTime = sdf.parse("2020-07-25 19:10:30");

        //指定定时任务

        //timer.schedule(定时任务，第一次执行时间时间，间隔多久执行一次)

        timer.schedule(new LogTimerTask(), firstTime, 1000 * 5);

    }

}

//编写一个定时任务

class LogTimerTask extends TimerTask {

    @Override

    public void run() {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String strTime = sdf.format(new Date());

        System.out.println(strTime + "：成功完成了一次数据备份！");

    }

}

6、通过Callable接口实现一个线程

使用Callable接口实现线程，可以获得该线程的返回值（JDK8新特性）

一个简单的实例：

package Thread;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

public class ThirdWay {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask futureTask = new FutureTask(new Task());

        Thread thread = new Thread(futureTask);

        thread.start();

        Object object = futureTask.get();  //通过get方法可以获取当前线程的返回值

        主线程中这里的程序必须等待get()方法结束才执行

        // get()方法为了拿另一个线程的执行结果需要等待其执行完成，因此要等待较长时间

        System.out.print("线程执行结果：");

        System.out.println(object);

    }

}

class Task implements Callable {

    @Override

    public Object call() throws Exception {

        System.out.println("call method begin");

        Thread.sleep(1000 * 10);

        System.out.println("call method end");

        int a = 100;

        int b = 200;

        return a + b;

    }

}

FutureTask类相关源码

public FutureTask(Callable<V> callable) {

        if (callable == null)

            throw new NullPointerException();

        this.callable = callable;

        this.state = NEW;       // ensure visibility of callable

    }



    public V get() throws InterruptedException, ExecutionException {

        int s = state;

        if (s <= COMPLETING)

            s = awaitDone(false, 0L);

        return report(s);

    }

Future类中实现了get方法获取传入线程的返回结果

7、Object类中的wait和notify方法

7.1、wait和notify方法介绍

wait和notify方法不是线程对象的方法，不能通过线程对象调用。

Object object=new Object();

object.wait();//object.wait()让正在object对象上活动的线程进入等待状态，无限等待，直到被唤醒为止

object.notify();//object.notify()唤醒正在object对象上等待的线程

object.notifyAll();//object.notifyAll唤醒正在object对象上等待的所有线程

7.2、生产者和消费者模式

一个简单的生产者和消费者实例

模拟生产者生产一个，消费者就消费一个。让仓库始终零库存。

package Thread;

import java.awt.*;

import java.util.*;

import java.util.List;

public class Producer_Consumer {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        Thread thread1 = new Thread(new Consumer(list), "消费者线程");

        Thread thread2 = new Thread(new Producer(list), "生产者线程");

        thread1.start();

        thread2.start();

    }

}

//消费者线程

class Consumer implements Runnable {

    //仓库

    private List<String> list;

    public Consumer(List<String> list) {

        this.list = list;

    }

    @Override

    public void run() {

        //消费

        while (true) {

            synchronized (list) {

                //如果仓库已经空了，消费者线程等待并释放list集合的锁

                if (list.size() == 0) {

                    try {

                        list.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                //仓库中有商品，消费者进行消费

                String str = list.remove(0);

                System.out.println(Thread.currentThread().getName() + " 消费 " + str);

                list.notify();  //唤醒生产者

            }

        }

    }

}

//生产者线程

class Producer implements Runnable {

    //仓库

    private List<String> list;

    public Producer(List<String> list) {

        this.list = list;

    }

    @Override

    public void run() {

        //生产

        while (true) {

            synchronized (list) {

                //如果仓库里有东西，则停止生产。生产者线程等待并释放list集合的锁

                if (list.size() > 0) {

                    try {

                        list.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                list.add("商品");

                System.out.println(Thread.currentThread().getName() + " 生产 " + list.get(0));

                list.notify();  //唤醒消费者

            }

        }

    }

}

：

7.3、实现奇偶数的交替输出

package Thread;

/**

 * 使用生产者和消费者模式实现两个线程交替输出：一个线程负责输出奇数，另一个线程负责输出偶数

 */

public class Number {

    public static void main(String[] args) throws InterruptedException {

        Num num = new Num(0);

        Thread thread1 = new Thread(new Odd(num), "Odd");

        Thread thread2 = new Thread(new Event(num), "Event");

        thread1.start();

        thread2.start();

    }

}

class Odd implements Runnable {

    Num num;

    public Odd(Num num) {

        this.num = num;

    }

    @Override

    public void run() {

        while (true) {

            synchronized (num) {

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                if (num.getI() % 2 == 0) {

                    try {

                        num.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                System.out.println(Thread.currentThread().getName() + "--->" + num.printNum());

                num.notifyAll();

            }

        }

    }

}

class Event implements Runnable {

    Num num;

    public Event(Num num) {

        this.num = num;

    }

    @Override

    public void run() {

        while (true) {

            synchronized (num) {

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                if (num.getI() % 2 != 0) {

                    try {

                        num.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                System.out.println(Thread.currentThread().getName() + "--->" + num.printNum());

                num.notifyAll();

            }

        }

    }

}

class Num {

    private int i = 0;

    public Num(int i) {

        this.i = i;

    }

    public int getI() {

        return i;

    }

    public void setI(int i) {

        this.i = i;

    }

    int printNum() {

        return i++;

    }

}

巴特西

java线程基础知识整理

线程基本概念