一、Java语言中，实现线程有三种方式。

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。

第一种：（不建议使用）
编写一个类，直接继承java.lang.Thread，重写run方法。

public class MyThread extends Thread{public void run(){ }
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();

第二种：（建议使用）
编写一个类，实现java.lang.Runnable接口，实现run方法。

// 定义一个可运行的类
public class MyRunnable implements Runnable {public void run(){}
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承
        其它的类，更灵活。

第三种：（带返回值的）
实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
        这种方式实现的线程可以获取线程的返回值。
        之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

// 实现Callable接口方式
class MyThread implements Callable{public Object call() throws Exception { System.out.println("call method begin");Thread.sleep(1000 * 5);System.out.println("call method end");int a = 100;int b = 100;return a + b; // 自动装箱}
}// main调用
FutureTask ft = new FutureTask(new MyThread());
Thread t = new Thread(ft);
t.start();
ft.get(); // 获取返回值（下面的代码需要在本行执行完毕(得到返回值)才会往下执行）

二、线程的生命周期

新建状态、就绪状态、运行状态、阻塞状态、死亡状态。

 三、关于线程的调度（了解）

（1）常见的线程调度模型有哪些？

        抢占式调度模型：
            那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
            java采用的就是抢占式调度模型。

        均分式调度模型：
            平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
            平均分配，一切平等。
            有一些编程语言，线程调度模型采用的是这种方式。

（2）线程调度有关的方法

实例方法：
            void setPriority(int newPriority) 设置线程的优先级
            int getPriority() 获取线程优先级
            最低优先级1
            默认优先级是5
            最高优先级10
            优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）

静态方法：
            static void yield()  让位方法
            暂停当前正在执行的线程对象，并执行其他线程
            yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
            yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
            注意：在回到就绪之后，有可能还会再次抢到。

实例方法:
void join() 在可以理解为插队

合并线程
class MyThread1 extends Thread {public void doSome(){MyThread t = new MyThread();t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。}
}
class MyThread extends Thread{                
}

（四）关于多线程并发环境下，数据的安全问题。（重点）

（1）什么时候数据在多线程并发的环境下会存在安全问题呢？
        三个条件：
            条件1：多线程并发。
            条件2：有共享数据。
            条件3：共享数据有修改的行为。

        满足以上3个条件之后，就会存在线程安全问题。

（2）怎么解决线程安全问题呀？
        线程排队执行。（不能并发）
        这种机制被称为：线程同步机制。

（3）编程模型
        异步编程模型：异步就是并发。
        同步编程模型：同步就是排队。

（4）synchronized（重点）

synchronized有三种写法：

        第一种：同步代码块
            灵活
            synchronized(线程共享对象){
                同步代码块;
            }

        第二种：在实例方法上使用synchronized
            表示共享对象一定是this
            并且同步代码块是整个方法体。
        
        第三种：在静态方法上使用synchronized
            表示找类锁。
            类锁永远只有1把。
            就算创建了100个对象，那类锁也只有一把。
        
        对象锁：1个对象1把锁，100个对象100把锁。
        类锁：100个对象，也可能只是1把类锁。

（5）变量的使用：

    第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

    第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
    实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，
    对象不共享，就没有数据安全问题了。）

    第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
    就只能选择synchronized了。线程同步机制。

（6）守护线程的使用

java语言中线程分为两大类：
            一类是：用户线程
            一类是：守护线程（后台线程）
            其中具有代表性的就是：垃圾回收线程（守护线程）。

        守护线程的特点：
            一般守护线程是一个死循环，所有的用户线程只要结束，
            守护线程自动结束。
        
        注意：主线程main方法是一个用户线程。

Thread t = new MyRunnable();
t.setName("守护线程");
// 在开启线程之前将t设置为守护线程
t.setDaemon(true);

  （7）关于Object类中的wait和notify方法。（生产者和消费者模式！）

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
        都有的方法，因为这两个方式是Object类中自带的。
        
第二：wait()方法作用？

Object o = new Object();
o.wait();

表示：
        让正在o对象上活动的线程进入等待状态，无期限等待，
        直到被唤醒为止。等待的时候会释放锁和占有的cpu时间片。
        o.wait();方法的调用，会让“当前线程（正在o对象上
        活动的线程）”进入等待状态。

 第三：notify()方法作用？

Object o = new Object();
o.notify();

表示：
        唤醒正在o对象上等待的线程。只是唤醒，并没有释放锁。
            
        还有一个notifyAll()方法：
                这个方法是唤醒o对象上处于等待的所有线程。

自用小总结，方便复习用。