并发编程之多线程基础

一。多线程创建方式

    1。第一种继承Thread类 重写run方法

class CreateThread extends Thread {

    // run方法中，需要线程需要执行代码
    @Override
    public void run() {
        System.out.println("运行子线程");
    }

}

public class ThreadDemo01 {

    public static void main(String[] args) {
        System.out.println("main... 主线程开始...");
        // 1.创建线程
        CreateThread CreateThread = new CreateThread();
        // 2.启动线程
        CreateThread.start();
        System.out.println("main... 主线程结束...");
    }

}

    2。 第二种实现Runnable接口,重写run方法

class CreateRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("运行子线程");
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        System.out.println("-----多线程创建开始-----");
        // 1.创建一个线程
        CreateRunnable createThread = new CreateRunnable();
        // 2.开始执行线程 注意 开启线程不是调用run方法，而是start方法
        System.out.println("-----多线程创建启动-----");
        Thread thread = new Thread(createThread);
        thread.start();
        System.out.println("-----多线程创建结束-----");
    }

}

     3。使用匿名内部类方式

public class ThreadDemo3 {
    public static void main(String[] args) {
        System.out.println("-----多线程创建开始-----");
        Thread thread = new Thread(new Runnable() {
            public void run() {
                System.out.println("运行子线程");
            }
        });
        
        thread.start();
        System.out.println("-----多线程创建结束-----");
    }
}

    注意：

        1>  一般使用Runnable接口，符合面向接口编程，而且实现了接口还可以继续继承，继承了类不能再继承。

    　 2> 开启线程不是调用run方法，而是start方法。

二。守护线程

    Java中有两种线程，一种是用户线程，另一种是守护线程。

    用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止。

    守护线程当进程不存在或主线程停止，守护线程也会被停止。

    使用setDaemon(true)方法设置为守护线程。如果不设置为守护线程，子线程还好运行。

public class DaemonThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("我是子线程...");
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {

            }
            System.out.println("我是主线程");
        }
        System.out.println("主线程执行完毕!");
    }
}

三。多线程运行状态

    线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

    1。新建状态

        当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码。

    2。就绪状态

        当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

        处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。

    3。运行状态

        当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。

    4。阻塞状态      

　 线程运行过程中，可能由于各种原因进入阻塞状态:
　　    1> 线程通过调用sleep方法进入睡眠状态；
　　    2> 线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
　　    3> 线程试图得到一个锁，而该锁正被其他线程持有；
　　    4> 线程在等待某个触发条件；

    5。死亡状态     

     有两个原因会导致线程死亡：
　　     1>  run方法正常退出而自然死亡，
　　     2> 一个未捕获的异常终止了run方法而使线程猝死。
     为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；

      如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false。

四。join()方法作用

    当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1，执行完子线程后才执行主线程。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("先执行子线程");
            }
        });
        t1.start();
        // 当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1
        t1.join();
        System.out.println("接着执行主线程");
    }
}

     2。优先级

     在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5。优先级越高，被分配执行的概率就越大。

class PrioritytThread implements Runnable {

    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().toString() + "---i:" + i);
        }
    }
}

public class ThreadDemo4 {
    public static void main(String[] args) {
        PrioritytThread prioritytThread = new PrioritytThread();
        Thread t1 = new Thread(prioritytThread);
        Thread t2 = new Thread(prioritytThread);
        t1.start();
        // 注意设置了优先级， 不代表每次都一定会被执行。 只是被CPU调度概率高。
        t1.setPriority(10);
        t2.start();
    }
}

    3。Yield方法

    yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。但可能会没有效果，因为该线程可能会再次被选中运行。

五。内置的锁

    Java提供了一种内置的锁机制来支持原子性，每一个Java对象都可以用作一个实现同步的锁，称为内置锁。

    线程进入同步代码块之前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁。

    内置锁为互斥锁，即线程A获取到锁后，线程B阻塞直到线程A释放锁，线程B才能获取到同一个锁。

    内置锁使用synchronized关键字实现，synchronized关键字有两种用法：

        *** 修饰需要进行同步的方法（所有访问状态变量的方法都必须进行同步），此时充当锁的对象为调用同步方法的对象。

        *** 同步代码块和直接使用synchronized修饰需要同步的方法是一样的，但是锁的粒度可以更细，并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活。

class SynObj{
    // 同步方法，锁对象为this
    public synchronized void showA(){
        System.out.println("showA..");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void showB(){
        // 同步代码块，锁对象为this
        synchronized (this) {
            System.out.println("showB..");
        }
    }

    public void showC(){
        String s="1";
        // 同步代码块，锁对象为s
        synchronized (s) {
            System.out.println("showC..");
        }
    }
    // 静态同步函数,锁是该函数所属字节码文件对象，可以使用this.getClass()方法获取，也可以用当前 类名.class表示。
    public static synchronized void showD(){
        System.out.println("showD..");
    }
}

public class TestSyn {
    public static void main(String[] args) {
        final SynObj sy=new SynObj();
        new Thread(new Runnable() {

            @Override
            public void run() {
                sy.showA();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                sy.showB();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                sy.showC();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                SynObj.showD();
            }
        }).start();
    }
}

    shouA和showC以及showD会立刻打印出来，showC三秒后才打印处理，因为showA和showB的锁对象都是this。

     2。多线程死锁

     多个并发进程因争夺系统资源而产生相互等待的现象。

    死锁产生的4个必要条件：

        1>  互斥：某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。

        2> 占有且等待：一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。

        3> 不可抢占：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。

        4> 循环等待：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。

    避免死锁：银行家算法等

六。ThreadLocal

    ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

    ThreadLocal类接口很简单，只有4个方法：

        1。void set(Object value)设置当前线程的线程局部变量的值。

        2。public Object get()该方法返回当前线程所对应的线程局部变量。

        3。public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用。

            当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

        4。protected Object initialValue()返回该线程局部变量的初始值。

            这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

class Res {
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        protected Integer initialValue() {
            return 0;
        };
    };

    public Integer getNumber() {
        int count = threadLocal.get() + 1;
        threadLocal.set(count);
        return count;
    }

}

public class ThreadLocaDemo2 extends Thread{
    private Res res;

    public ThreadLocaDemo2(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "," + res.getNumber());
        }
    }

    public static void main(String[] args) {
        Res res = new Res();
        ThreadLocaDemo2 t1 = new ThreadLocaDemo2(res);
        ThreadLocaDemo2 t2 = new ThreadLocaDemo2(res);
        t1.start();
        t2.start();
    }
}

    ThreadLoca实现原理：

    每个Thread的对象都有一个ThreadLocalMap，当创建一个ThreadLocal的时候，就会将该ThreadLocal对象添加到该Map中，其中键就是ThreadLocal，值可以是任意类型。

七。多线程三大特性

    1。原子性：一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

    2。可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

    3。有序性：程序执行的顺序按照代码的先后顺序执行。

        一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化。

        它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。