1.创建线程
线程表示一条单独的执行流，它有自己的程序执行计数器，有自己的栈
创建线程有两种方式：一种是继承Thread，另外一种是实现Runnable接口。
（1）继承Thread
Java中java.lang.Thread这个类表示线程，一个类可以继承Thread并重写run方法来实现一个线程。
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("hello");
}
}
线程需要启动的话，得执行start方法。
public static void main(String[] args) {
Thread thread = new MyThread();
thread.start();
}
如果不执行start方法，那么run方法就只是一个普通的方法。
每个线程都有一个id和name，要获取它们，可以使用getId()和getName()方法，要获取当前执行的线程，可以使用currentThread()方法。
修改上面的run方法
@Override
public void run() {
System.out.println("thread name:" + Thread.currentThread().getName());
System.out.println("hello");
}
如果在main方法中通过start方法启动线程，则输出
thread name:Thread-0
hello
如果直接调用run方法，这输出
thread name:main
hello
调用start方法后，就有两条执行流，一条执行run方法，一条执行main方法，两条执行流并发执行，操作系统负责调度。
（2）实现Runnable接口
通过继承Thread来实现线程比较简单，但java只支持单继承，这时就可以通过实现Runnable接口来实现线程，Runnable接口只有一个run方法。
public class MyThread implements Runnable {
@Override
public void run() {
System.out.println("hello");
}
}
启动线程同样要使用start方法，不过创建一个线程的方式有所不同
public static void main(String[] args) {
Thread thread = new Thread(new MyThread());
thread.start();
}
2.线程的基本属性和方法
（1）id和name
前面我们已经说过了，每个线程都有一个id和name，id是一个递增的整数，每创建一个线程就加1.name的默认值是Thread-后面跟一个编号，name可以在Thread的构造方法中指定。也可以通过setName方法进行设置，给Thread设置一个友好的名字，可以方便测试。
（2）优先级
线程有一个优先级的概念，优先级从1到10，默认是5，可以通过setPriority方法设置。不同的操作系统略有不同。
public final void setPriority(int newPriority)
public final int getPriority()
（3）状态
线程有一个状态的概念，Thread有一个getState方法可以获取线程的状态。
public State getState()
返回值为Thread.State，它是一个枚举类型，有如下值
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
NEW：没有调用的线程状态。
RUNNABLE：调用start后线程在执行run方法且没有阻塞。
TERMINATED：线程运行结束后状态为TERMINATED。
BLOCKED，WAITING，TIMED_WAITING：都表示线程被阻塞了，在等等一些条件。
Thread还有一个方法，表示线程是否还活着
public final native boolean isAlive()
线程被启动后，run方法运行结束前，此方法返回值都是true。
（4）是否是daemon线程
Thread有一个是否daemon线程的属性，相关方法：
public final void setDaemon(boolean on)
public final boolean isDaemon()
前面我们说了，启动线程会启动一条单独的执行流，整个程序只有在所有线程都执行完毕后才会退出，但daemon线程除外，当整个程序剩下的都是daemon线程时，程序就会退出。
daemon线程其实就是后台进程，比如垃圾收集器。作用就是辅助其他的线程，当其他的线程执行完毕后，它们也就没有存在的必要了。
（5）sleep方法
调用该方法可以使当前线程睡眠，但不释放对象锁
public static void **sleep**(long millis) throws InterruptedException
（6）yield方法
Thread还有一个让出CPU的方法
public static native void yield()
调用该方法，是告诉系统的调度器：我现在不着急使用CPU，你可以让其他线程先运行。
（7）join方法
调用该方法，可以让其他线程等待调用这个方法的线程结束。
public final void join() throws InterruptedException
比如前面的main线程和thread线程，如果希望main线程在thread线程结束后再退出，则加上
thread.join()
3.共享内存及可能存在的问题
（1）共享内存
public class ShareMemoryDemo {
private static int shared = 0;
private static void incrShared() {
shared++;
}
static class ChildThread extends Thread {
List list;
public ChildThread(List list) {
this.list = list;
}
@Override
public void run() {
incrShared();
list.add(Thread.currentThread().getName());
}
}
public static void main(String[] args) throws InterruptedException {
List list = new ArrayList();
Thread t1 = new ChildThread(list);
Thread t2 = new ChildThread(list);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(shared);
System.out.println(list);
}
}
大部分情况下，会输出如下
2
[Thread-0, Thread-1]
通过这个例子，说明执行流、内存和代码的关系如下：
- 该代码中有三条执行流，一条执行main方法，另外两条执行ChildThread 的run方法。
- 不同执行流可以访问和操作相同的变量，如本例中的shared和list变量。
- 不同的执行流可以执行相同的代码。
- 当多条执行流执行相同的d代码时，每条执行流都有单独的栈，方法中的参数和局部变量都有自己的一份。
（2）竞态条件
竞态条件是指当多个线程访问和操作同一变量的时候，执行的结果和执行次序有关，结果可能正确也可能不正确。
public class CounterThread extends Thread {
private static int counter = 0;
@Override
public void run() {
for(int i = 0; i < 1000; i++) {
counter++;
}
}
public static void main(String[] args) throws InterruptedException {
int num = 1000;
Thread[] threads = new Thread[num];
for(int i = 0; i < num; i++) {
threads[i] = new CounterThread();
threads[i].start();
}
for(int i = 0; i < num; i++) {
threads[i].join();
}
System.out.println(counter);
}
}
期望的结果是1000*1000，但运行输出一般不是这个数。
因为counter++不是一个原子操作，主要分成以下三步
- 取得counter的值
- counter的值加1
- 将新值重新赋给counter
这样的情况下，如果我们两个线程同时取得了counter的值，比如100，那么第一个线程执行完后counter的值为101，第二个线程执行完后，counter的值还是101，这肯定会与我们的期望值不一样。
解决这个问题的方法有：
- 使用synchronized关键字
- 使用显式锁
- 使用原子变量
这个在后面的文章中我会一一讲。
（3）内存可见性
所谓内存可见性，就是一个线程对变量的修改，其他的线程能够马上看到。因为多个线程可以共享和操作相同的变量，所以如果一个线程对变量的修改，其他的线程不能马上看到，甚至永远也看不到，这就会出错了。
public class VisibilityDemo {
private static boolean shutdown = false;
static class HelloThread extends Thread {
@Override
public void run() {
while(!shutdown) {
System.out.println("1");
}
System.out.println("exit hello");
}
}
public static void main(String[] args) throws InterruptedException {
new HelloThread().start();
Thread.sleep(1000);
shutdown = true;
System.out.println("exit main");
}
}
上面的程序中，一开始shutdown变量的值为false，这样启动线程后就会一直打印1，在main方法中，启动线程后，我们休息一下，然后把shutdown的值设为true，期望应是停止打印1，但结果可能是一直循环下去。
这就是内存可见性问题，在计算机系统中，除了内存，数据还会被缓存到cup的寄存器以及各级缓存中，当访问一个变量的时候，可能是直接从寄存器或缓存中读取，当修改变量的时候，也可能是先写到缓存中，之后才会同步更新到内存中，这是延迟写。在单线程中，这一般没问题，但在多线程中，就可能出现很严重的问题，一个线程对另一个变量的修改，另一个线程看不懂，一是没有及时同步到内存，二是另一个线程根本没从内存中读。
解决这个问题，有以下方法：
- 使用volatile关键字
- 使用synchronized关键字或显式锁同步。
4.线程的优缺点
优点：
- 能充分利用多cpu的能力。
- 充分利用硬件资源，cpu和硬盘。
- 简化模型及IO处理
缺点：
线程的调度和切换都需要花费时间，当有大量可运行线程的时候，操作系统会忙于调度，为一个线程分配一段时间，执行完后，再让另一个线程执行，一个线程被切换出去，操作系统需要保存它的当前上下文状态到内存，上下文状态包括当前cpu寄存器的值，程序计数器的值等，当一个线程被切换回来后，操作系统又要恢复它的上下文，整个过程就是上下文切换。这个切换不仅耗时，而且使cpu中的好多缓存失效。