并发编程之多线程基础

时间  2019-11-08
标签 并发 编程 之多 线程 基础 繁體版
原文   原文链接

一。多线程建立方式算法

    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("-----多线程建立结束-----");
    }
}

    注意：ide

        1>  通常使用Runnable接口，符合面向接口编程，并且实现了接口还能够继续继承，继承了类不能再继承。函数

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

二。守护线程this

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

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

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

    使用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。有序性：程序执行的顺序按照代码的前后顺序执行。

        通常来讲处理器为了提升程序运行效率，可能会对输入代码进行优化。

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程