多线程与同步代码块详解

作者: 阿Q说代码 | 来源:发表于2019-03-08 15:05 被阅读1次

线程是程序执行的一条路径，一个进程中可以包含多条线程。多线程并发执行可以提高程序的效率，可以同时完成多项工作，多线程并发执行的实质就是CPU在做着高速的切换。多线程的应用场景：红蜘蛛同时共享屏幕给多个电脑；迅雷开启多条线程一起下载；QQ同时和多个人一起视频；服务器同时处理多个客户端请求。

并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

代码验证：

public class Demo1_Thread { //此程序的运行结果是 "我是主线程的执行代码"和"垃圾被清扫了"交替执行
    /**
    证明jvm是多线程的
     */
    public static void main(String[] args) {
        for(int i = 0; i < 100000; i++) {
            new Demo();
        }

        for(int i = 0; i < 10000; i++) {
            System.out.println("我是主线程的执行代码");
        }
    }
}

class Demo {
    @Override
    public void finalize() {
        System.out.println("垃圾被清扫了");
    }

}

多线程的实现

方式一：定义类继承Thread，重写run方法，把新线程要做的事写在run方法中；创建线程对象，开启（调用start()）新线程, 内部会自动执行run方法。

代码演示：

public class Demo2_Thread {
    public static void main(String[] args) {
        MyThread mt = new MyThread();       //4,创建Thread类的子类对象
        mt.start();             //5,开启线程
        MyThread mt1 = new MyThread();
        mt1.start();

        for(int i = 0; i < 1000; i++) {
            System.out.println("bb");
        }
    }

}
class MyThread extends Thread {     //1,继承Thread
    public void run() {             //2,重写run方法
        for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
            System.out.println("aaaaaaaaaaaa");
        }
    }
}

方式二：定义类实现Runnable接口，实现run方法，把新线程要做的事写在run方法中，创建自定义的Runnable的子类对象，创建Thread对象，传入Runnable，调用start()开启新线程，内部会自动调用Runnable的run()方法。

代码演示：

public class Demo3_Thread {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();   //4,创建Runnable的子类对象
        Thread t = new Thread(mr);      //5,将其当作参数传递给Thread的构造函数
        t.start();              //6,开启线程
        for(int i = 0; i < 1000; i++) {
            System.out.println("bb");
        }
    }

}
class MyRunnable implements Runnable {          //1,定义一个类实现Runnable

    @Override
    public void run() {             //2,重写run方法
        for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
            System.out.println("aaaaaaaaaaaa");
        }
    }

}

剖析实现Runnable接口的源码

源码解释：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的run()，运行时执行的是子类的run()方法。

源码解析：

public class Thread implements Runnable {   //Thread类本身实现了Runnable接口
    /*省略代码*/

    private Runnable target;    //一个Runnable类型的成员变量

    public Thread(Runnable target) {//Thread的有参构造方法，传入一个Runnable接口的子类对象target
        //调用init方法（下面这个） 把target传入
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {    
        //init方法里面又调用另一个重载的init方法（下面这个）把target传入
        init(g, target, name, stackSize, null);     
    }
    private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {
        /*省略代码*/
        this.target = target;//在init方法里面把成员变量target 进行赋值
        /*省略代码*/
    }
    public synchronized void start() {  //当调用start方法的时候 内部调用的是start0()方法
        /*省略代码*/
        start0();
        /*省略代码*/
    }

    private native void start0();   //start0()是native修饰的方法 底层是其他语言 我们无法查看，但是我们知道底层会调用run方法

    @Override
    public void run() {     //start0()的底层是会调用run()方法
        if (target != null) {   //判断成员变量target是否为null
            target.run();   //如果target被赋值了，就要调用target的run方法
        }
    }
    /*省略代码*/
}

多线程两种实现方式的区别

继承Thread : 由于子类重写了Thread类的run()，当调用start()时, 直接找子类的run()方法；好处是:可以直接使用Thread类中的方法,代码简单；弊端是:如果已经有了父类，就不能用这种方法。

实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run()，运行时执行的是子类的run()方法。好处是:即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的；弊端是:不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂。

匿名内部类实现线程的两种方式

public static void main(String[] args) {
    new Thread() {                              //1,继承Thread类
        public void run() {                     //2,重写run方法
            for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
                System.out.println("aaaaaaaaaaaaaa");
            }
        }
    }.start();                                  //4,开启线程

    new Thread(new Runnable() {                 //1,将Runnable的子类对象传递给Thread的构造方法
        public void run() {                     //2,重写run方法
            for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
                System.out.println("bb");
            }
        }
    }).start();                                 //4,开启线程
}

public final String getName()：获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)
public final void setName(String name):设置线程名称。

代码演示：

//通过构造方法给name赋值
public static void demo1() {
    new Thread("芙蓉姐姐") {        //通过构造方法给name赋值
        public void run() {
            System.out.println(this.getName() + "....aaaaaaaaa");
        }
    }.start();
}
//通过setName()来设置线程的名字
public static void main(String[] args) {

    Thread t = new Thread() {
        public void run() {
            //this.setName("张三");       //在这儿设置也行  在外面设置名称也行
            System.out.println(this.getName() + "....aaaaaaaaaaaaa");
        }
    };

    t.setName("张三");    //通过setName()来设置线程的名字
    t.start();
}

public static Thread currentThread():返回当前正在执行的线程对象引用

public static void sleep(long millis):让当前线程休眠millis毫秒

public final void setDaemon(boolean on)：设置线程为守护线程，一旦前台(主线程)结束，守护线程就结束了

public final void join():当前线程暂停，等待指定的线程执行结束后，当前线程再继续

public final void join(long millis)：当前线程暂停, 等待指定的线程执行millis毫秒结束后, 当前线程再继续

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。

public final int getPriority():获取线程优先级

public final void setPriority(int newPriority):更改线程的优先级。线程默认优先级是5。范围是1-10。

注意：优先级可以在一定的程度上，让线程获较多的执行机会。

代码演示：

public static void main(String[] args) {
    final Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                System.out.println(getName() + "...aaaaaaaaaaaaa");
            }
        }
    };

    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                if(i == 2) {
                    try {
                        t1.join();  //t1插队后，t1执行结束后 t2才能接着执行
                        //t1.join(1);   //插队指定的时间,过了指定时间后,两条线程交替执行
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(getName() + "...bb");
            }
        }
    };
    t1.start();
    t2.start();
}

同步代码块

当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步。如果两段代码是同步的，那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码。所谓同步代码块就是使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块，多个同步代码块如果使用相同的锁对象，那么他们就是同步的。

代码演示

public class Demo_Synchronized {
    public static void main(String[] args) {
        //匿名内部类使用局部变量，局部变量前面必须加final修饰，为了延长局部变量的声明周期
        final Printer p = new Printer();    

        new Thread() {
            public void run() {
                while(true) {
                    p.print1(); //调用print1()
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    p.print2(); //调用print2()
                }
            }
        }.start();
    }

}

class Printer {
    Demo d = new Demo();
    public void print1() {  
        synchronized(d) {   //同步代码块,锁机制,锁对象可以是任意的
            //当多线程并发, 有多段代码同时执行时
            //我们希望下面代码执行的过程中CPU不要切换到其他线程工作
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
        }
    }

    public void print2() {                      
        synchronized(d) {//如果说两块代码想同步的话，那么这两个同步代码块的锁对象必须是同一个锁对象，所以说上面的锁对象是d，这一个锁对象也是d
            //我们希望下面代码执行的过程中CPU不要切换到其他线程工作
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}

class Demo{}

同步方法

使用synchronized关键字修饰一个方法，该方法中所有的代码都是同步的，非静态同步函数的锁是当前对象this，静态的同步函数的锁是当前类的字节码对象。

代码演示：

public class Demo_Synchronized {
    public static void main(String[] args) {
        //匿名内部类使用局部变量，局部变量前面必须加final修饰，为了延长局部变量的声明周期
        final Printer2 p = new Printer2();

        new Thread() {
            public void run() {
                while(true) {
                    p.print1();
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    p.print2();
                }
            }
        }.start();
    }
}

class Printer2 {
    Demo d = new Demo();
    //非静态的同步方法的锁对象是神马?
    //答:非静态的同步方法的锁对象是this
    //静态的同步方法的锁对象是什么?
    //是该类的字节码对象
    public static synchronized void print1() {//同步方法只需要在方法上加synchronized关键字即可
        System.out.print("黑");
        System.out.print("马");
        System.out.print("程");
        System.out.print("序");
        System.out.print("员");
        System.out.print("\r\n");
    }

    public static void print2() {
        synchronized(Printer2.class) {      
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}

死锁
同步代码块的嵌套就容易出现死锁。所以开发中尽量避免同步代码块的嵌套。

代码演示：

public class Demo5_DeadLock {
    /**
    @param args
    */
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";

    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s1) {
                        System.out.println(getName() + "...获取" + s1 + "等待" + s2);
                        synchronized(s2) {
                            System.out.println(getName() + "...拿到" + s2 + "开吃");
                        }
                    }
                }
            }
        }.start();


        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s2) {
                        System.out.println(getName() + "...获取" + s2 + "等待" + s1);
                        synchronized(s1) {
                            System.out.println(getName() + "...拿到" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();
    }
}

Vector,StringBuffer,Hashtable这些类之所以说是同步的，是因为他们里面的方法上都加了synchronized

Collections.synchroinzedXxx(xxx)：可以返回一个线程安全的集合
public static <T> Collection<T> synchronizedCollection(Collection<T> c)
public static <T> Set<T> synchronizedSet(Set<T> s)
public static <T> List<T> synchronizedList(List<T> list)
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

注：Vector是线程安全的,ArrayList是线程不安全的

StringBuffer是线程安全的,StringBuilder是线程不安全的

Hashtable是线程安全的,HashMap是线程不安全的

想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。

多线程与同步代码块详解

多线程的实现

同步代码块

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java基础入门