多线程(Multi-Thread)

线程与进程

进程:执行中的程序（程序是静态的概念，进程是动态的概念）。
Java中如果我们自己没有产生线程，那么系统就会给我们产生一个线程（主线程，main方法就在主线程上运行），我们的程序都是由线程来执行的。

线程与进程区别

一个进程中包含多个线程，线程与进程是从属关系。

多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和系统资源，有可能相互影响

线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程的切换的负担要小。

多线程程序比多进程程序需要更少的管理费用。进程是重量级的任务，需要分配给它们独立的地址空间。进程间通信是昂贵和受限的，进程间的转换也是很需要花费的。另一方面，线程是轻量级的选手。它们共享相同的地址空间并且共同分享同一个进程。线程间通信是便宜的，线程间的转换也是低成本的。

线程的实现

线程的实现有两种方式，第一种方式是继承Thread类，然后重写run方法，第二种是实现Runnable接口，然后实现其run方法。
将我们希望线程执行的代码放到run方法中，然后通过start方法来启动线程，start方法首先为线程的执行准备好系统资源，然后再去调用run方法。当某个类继承了Thread
类之后，该类就叫做一个线程类。

public class ThreadTest {
    public static void main(String[] args) {
        new Thread1().start();
        new Thread2().start();
    }
}
class Thread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("hello world "+i);
        }
    }
}
class Thread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("welcome" + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        new Thread(new MyThread()).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("welcome "+i);
                }
            }
        }).start();
    }
}
class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("hello world "+i);
        }
    }
}

一个进程至少要包含一个线程。
对于单核CPU来说，某一时刻只能有一个线程在执行（微观串行），从宏观角度来看，多个线程在同时执行（宏观并行）。
对于双核或双核以上的cpu来说，可以真正做到微观并行。

Thread类也实现了Runnable接口，因此实现了Runnable接口中的run方法；

当生成一个线程对象时，如果没有为其设定名字，那么线程对象的名字将使用如下形式：Thread-number，该number将是自动增加的，并被所有的Thread对象共享（因为它是static的成员变量）。

当使用第一种方式来生成线程对象时，我们需要重写run方法，因为thread类的run方法此时什么事情也不做。
当使用第二种方式来生成线程对象时，我们需要实现Runnable接口的run方法，然后使用new Thread(new MyThread())来生成线程对象，这时的线程对象的run方法就会调用MyThread类的run方法，这样我们自己编写的run方法就执行了。

public
class Thread implements Runnable {
    ......
    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    ......
}

线程的生命周期

四个状态：

创建状态
可运行状态
不可运行状态
消亡状态

thread

关于成员变量和局部变量：如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作时它们对该成员变量是彼此影响的（也就是说一个线程对成员变量的改变会影响到另一个线程）
如果一个变量是局部变量，那么每个线程都会有一个该局部变量的拷贝，一个线程对该局部变量的改变不会影响到其他线程。

public class ThreadTest3 {
    public static void main(String[] args) {
        HelloThread helloThread = new HelloThread();
        new Thread(helloThread).start();
        new Thread(helloThread).start();
    }
}
class HelloThread implements Runnable {
    //int i = 0;
    @Override
    public void run() {
        int i = 0;
        while (true) {
            System.out.println("number:" + i++);
            try {
                Thread.sleep((long) Math.random() * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (50 == i) {
                break;
            }
        }
    }
}

停止线程的方式：不能使用Thread类的stop方法来终止线程的执行。一般要设定一个变量，在run方法中是一个循环，循坏每次检查该变量，如果满足条件则继续执行，否则跳出循环，线程结束。
不能依靠线程的优先级来决定线程的执行顺序。

多线程的同步

synchronized关键字：当synchronized关键字修饰一个方法的时候，该方法叫同步方法。
java中的每个对象都有一个锁（lock）或者叫做监视器（monitor），当访问某个对象的synchronized方法时，表示将该对象上锁，此时其他任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后（或者是抛出了异常），那么将该对象的锁释放掉，其他线程才有可能再去访问该synchronized方法。
如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在改方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。
如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为java中无论一个类有多少对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。

synchronized块，写法：

1
2
3

synchronized(object){
    
}

表示线程在执行的时候会对object对象上锁。

synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法；synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的代码是可以被多个线程同时访问到的。

死锁(deadlock)

wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。

另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。

线程与进程

线程与进程区别

线程的实现

线程的生命周期

多线程的同步

线程组