浅谈线程（Java）

线程及其一些相关概念

进程是操作系统中进行保护和资源分配的基本单位，操作系统分配资源以进程为基本单位。而线程是进程的组成部分，它代表了一条顺序的执行流。
其中main方法为主线程，其他开辟的线程称为子线程。
每创建一个新的线程，就会开辟一个新的栈。
当执行多个线程的时候拷贝run方法以及其内部生成的变量各一份。
（由此可以看出，run方法是绝对安全的，对run方法进行上锁是毫无意义的。因为每个线程，都有其单独的run方法，该run方法与其他线程的 run 方法没有任何关联）
此处需注意的是：拷贝的只有栈里的内容，堆里的内容不可拷贝。

多线程的使用场景

在产生cpu明显浪费的情况下

创建一个新的线程

public class Test extends Thread{
    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {
        Test a = new Test();
        a.start();
    }
}

运行后可见输出结果

这是一个线程

注意：启动一个线程调用的是start方法而不是run方法，如直接调用run方法，该run方法只会当作一个普通方法调用，而不是启动一个线程

join方法的使用

请看如下代码

public class Test extends Thread{
    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {
        Test a = new Test();
        a.start();
        System.out.println("我觉得我会后出来");
    }
}

按照正常代码的执行顺序，我们很自然的以为输出结果应该是这样的

这是一个线程
我觉得我会后出来

然而事实却不是这样的
正确输出为

我觉得我会后出来
这是一个线程

此时若想让线程按照你所想的顺序执行，就需要调用join方法
将子线程插入主线程中，等子线程执行完在执行主线程、
使用该方法时，记得要对他进行异常处理

public class Test extends Thread{
    @Override
    public void run() {
        System.out.println("这是一个线程");
    }

    public static void main(String[] args) {
        Test a = new Test();
        a.start();
        try {
            a.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我觉得我会后出来");
    }
}

此时执行结果为

这是一个线程
我觉得我会后出来

sleep方法

让线程沉睡多少毫秒以后再继续执行

public class Test extends Thread{
    String name;
    Test(String name){
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i <10;i++) {
            System.out.println(name+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Test a = new Test("一号");
        Test b = new Test("二号");
        a.start();
        b.start();
        try {
            a.join();
            b.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我觉得我会后出来");
    }
}

这样便可让个线程交替进行
输出结果如下

二号0
一号0
二号1
一号1
一号2
二号2
一号3
二号3
二号4
一号4
一号5
二号5
二号6
一号6
二号7
一号7
一号8
二号8
二号9
一号9
我觉得我会后出来

每个时刻每个cpu只能执行一个线程，当一个线程沉睡退出时，另一个线程便可进入执行

锁

解决的问题：当多个线程对同一公共资源进行访问修改时，很可能会出现的脏数据（例：A线程将公共资源从2修改为10，而B线程随后访问公共资源将其从原本2改到4并修改该公共资源，数据回退）

关键字：synchronized

锁只能对方法上锁。

需注意的是：方法是拷贝的一份，绝对安全，不需要锁。锁的是方法里的变量（不是从方法内部生成的变量，共享资源）所以锁的是含有目的资源的方法，锁的范围越小，性能越高

当被锁方法对共同区域（堆里）只进行读取或修改操作，霸占该区域的时间越短，时间性能越高

静态锁属于类锁（在一块区域）
非静态的属于对象锁（每个线程各自拷贝）

对类中操作同一共享资源的所有非静态方法进行加锁，所有操作这一共享资源的非静态方法会按顺序执行，即互相锁定(注意非静态方法操作的是同一个对象，否则会锁不住)，静态方法加锁也是可以互相锁定的。这两个相互锁定都有一个前提条件：必须操作的同一共享资源。

类锁和对象锁不能互相锁定