Java学习笔记（八）——多线程

69 阅读 0 评论 46 点赞

我是靠谱客的博主激动长颈鹿，最近开发中收集的这篇文章主要介绍Java学习笔记（八）——多线程，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

创建线程的第一种方式：继承Thread类

步骤：
①定义类继承Thread
②复写Thread类中的run方法，目的：将自定义代码存储在run方法中，让线程运行
③调用线程的start方法，该方法两个作用：启动线程，调用run方法
Thread为什么要覆盖run方法呢？
Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法，也就是说Thread类中的run方法，用于存储线程要运行的代码。

代码示例
class Test_thread extends Thread{
    public void run(){
        for(int x=0;x<20;x++)
            System.out.println(this.getName()+" run---"+x);
    }
}
class 线程 {
    public static void main(String[] args) {
        Test_thread t1=new Test_thread();
        Test_thread t2=new Test_thread();
        t1.start();
        t2.start();
        for(int x=0;x<20;x++)
            System.out.println("main---"+x);
    }
}

创建线程的第二种方式：实现Runnable接口

步骤：
①实现类实现Runnable接口
②覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中
③通过Thread类建立线程对象
④将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数，
⑤调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
为什么要将Runnable接口的子类对象传递给Thread的构造函数，
因为，自定义的run方法所属的对象是Runnable接口的子类对象，
所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象
实现方式和继承方式有什么区别？
实现方式好处，避免了单继承的局限性
继承方式好处，建立使用实现方式
两种方式区别：
线程Thread：线程代码存放Thread子类的run方法中
实现Runnable：线程代码存在接口的子类的run方法中

/*
需求：简单的卖票程序。多个窗口同时买票
*/
class Ticket implements Runnable{//extends Thread{
    private int tick=50;
    public void run(){
        while(true)
            if (tick > 0) {
            	try {
            		Thread.sleep(10);
            	} catch (Exception e) {
            	}
            	System.out.println(Thread.currentThread().getName() + "---sale: " + tick--);
            }
    }
}
public class thread_example_2 {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

通过分析上面代码，发现，打印出0、-1、-2等错票。
多线程的运行出现了安全问题。

问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

创建线程的第三种方式：实现Callable接口（了解即可）

多线程同步代码块

Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。

synchronized(对象){
需要被同步的代码
}

对象如同锁，持有锁的线程可以在同步中执行；没有持有锁的线程即使获取CPU的执行权，也无法执行
同步的前提：
①必须要有两个或者两个以上的线程；
②必须是多个线程使用同一个锁，必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，较为消耗资源。

/*
需求：简单的卖票程序。多个窗口同时买票
*/
class Ticket implements Runnable{//extends Thread{
    private int tick=50;
    Object obj=new Object();
    public void run() {
        while (true)
            synchronized (obj) {
                if (tick > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                    }
                    System.out.println(Thread.currentThread().getName() + "---sale: " + tick--);
                }
            }
    }
}
public class thread_example_2 {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

多线程同步函数

如何判断目标程序是否有安全问题？如果有，如何解决？
①明确哪些代码是多线程运行代码；
②明确共享数据；
③明确多线程运行代码中那些语句是操作共享数据的。

函数需要被对象调用，匿名函数都有一个所属对象引用，就是this。
所以同步函数使用的锁是this

静态进内存是内存中没有本类对象，但是一定有该类对应的字节码文件对象（类名.class）。
所以静态的同步方法，使用的锁是该方法所在类的字节码文件对象类名.class

/*
需求：简单的卖票程序。多个窗口同时买票
*/
class Ticket implements Runnable{//extends Thread{
    private int tick=50;//public static int tick=50;
    boolean flag=true;
    public void run() {
        if(flag) {
            while (true)
                synchronized (this) {//synchronized(Ticket.class)
                    if (tick > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName() + "---sale: " + tick--);
                    }
                }
        }
        else
            while(true)
                show();
    }
    public synchronized void show(){
        if (tick > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "---sale: " + tick--);
        }
    }
}
public class thread_example_2 {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag=false;
        t2.start();

    }
}

多线程死锁

多线程死锁的四个必要条件，只要其中任一条件不成立，死锁就不会发生。

互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。即存在一个处于等待状态的进程集合{Pl, P2, …, pn}，其中Pi等待的资源被P(i+1)占有（i=0, 1, …, n-1)，Pn等待的资源被P0占有。

代码示例
class Test implements Runnable{
    private boolean flag;
    Test(boolean flag){
        this.flag=flag;
    }
    public void run(){
        if(flag){
            synchronized (Mylock.locka){
                System.out.println("if locka");
                synchronized (Mylock.lockb) {
                    System.out.println("if lockb");
                }
            }
        }
        else{
            synchronized (Mylock.lockb){
                System.out.println("else lockb");
                synchronized (Mylock.locka) {
                    System.out.println("else locka");
                }
            }
        }
    }
}
class Mylock{
    static Object locka=new Object();
    static Object lockb=new Object();
}
class DeadTest{
    public static void main(String[] args) {
        Thread t1=new Thread(new Test(true));
        Thread t2=new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}