多线程（Thread）:

多线程实现方式：

继承Thread类： 

/**
 * 创建多线程一：继承Thread类
 */
public class Test extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("mythread"+i);
        }
    }
}

/**
 * 创建多线程一：继承Thread类
 */
public class Test2 {
    //mai方法是由一条默认的主线程负责执行
    public static void main(String[] args) {
        Test test=new Test();
        //向cpu注册一个新的线程
        test.start();
        //不能把主线程任务放在启动子线程之前。负责主线程一直是先跑的，相当于单线程效果。
        //不能使用run方法
        //test.run();
        for (int i = 0; i < 5; i++) {
            System.out.println("test2"+i);
        }
    }

}

实现Runnable接口 

/**
 * 继承多线程二：实现Runnable接口
 */
public class Test3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("test3:"+i);
        }
    }
}

/**
 * 继承多线程二：实现Runnable接口
 */
public class Test4 {
    public static void main(String[] args) {
        //创建的是任务对象
        Runnable target=new Test3();
        new Thread(target).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("Test4:"+i);
        }
    }
}

实现Runnable接口(用匿名内部类)： 

/**
 * 继承多线程二：实现Runnable接口(用匿名内部类)
 */
public class Test5 {
    public static void main(String[] args) {
        Runnable target=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程一："+i);
                }
            }
        };
        new Thread(target).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2："+i);
                }
            }
        }).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("线程"+i);
        }

    }
}

基于Callable接口，FutureTask类实现多线程：

/**
 * 基于Callable接口，FutureTask类实现多线程。
 */
public class Test6 implements Callable<String> {
    int n;

    public Test6(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum=0;
        //描述线程的任务，返回线程执行返回后的结果
        //需求，求1——n的和返回。
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return "线程求出的和"+sum;
    }
}

public class Test7 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> test6 = new Test6(50);
        //把callable的对象封装成一个FutureTask对象，（任务对象）
        FutureTask<String> stringFutureTask = new FutureTask<>(test6);
        new Thread(stringFutureTask).start();
        //获取线程执行完毕后的结果
        //注意：会等待上面的进程执行完毕后才进行下面的进程。
        String s = stringFutureTask.get();
        System.out.println(s);
    }
}

保证线程依次执行：

线程1.join（）；

线程2.join（）；

线程3.join（）；

线程同步：

悲观锁：

性能比较差

加锁的方法：

1，同步代码块

作用：把访问共享资源的核心代码给加上锁，以此保证线程安全。

非静态方法的话官方的锁建议锁共同资源“this”。

即实例方法建议使用共享发法作为锁对象，对于实例方法建议使用this作为锁的对象。

静态方法使用类名.class进行锁：

对于静态方法建议使用字节码（类名.class）对象作为锁的对象。

2，同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全。

在方法上加锁！

3，Lock锁：

该锁是一个接口不能直接创建对象的。

注意：所对象加上final关键字。不允许他改变。

将锁的对象创建在类的变量里面。方便使用。

CTRL+alt+t键产生快捷方法。

使用try -catch异常修饰，防止程序异常报错，导致锁永远被所住。

  乐观锁：

拿到数据后记录数据，更该数据时，查看原数据是否更改，若没有更改，则修改数据，若更改，则取消此次更改。