Java笔记(十九)……多线程

概述

进程：

是一个正在执行中的程序

每一个进程执行都有一个执行顺序，该执行顺序是一个执行路径，或者叫一个控制单元

线程：

就是进程中的一个独立的控制单元，线程在控制着进程的执行

一个进程中至少有一个线程

Java JVM启动的时候会有一个进程java.exe，该进程中至少有一个线程负责Java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程，与C类似，java.exe相当于所有进程的父进程，而且JVM启动了不止一个线程，还有负责垃圾回收的线程

创建线程

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

class Sell extends Thread
{
    private int tickets = 100;
    Sell()
    {
        //启动线程
        start();
    }
    //复写Thread类中的run方法，将线程运行所需的代码写到run方法中
    public void run()
    {
        while(tickets > 0)
        {
            System.out.println("tickets = "+tickets--);
        }
    }
}

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

class Sell implements Runnable
{
    private int tickets = 100;

    //实现Runnable接口的run方法
    public void run()
    {
        while(tickets > 0)
        {
            System.out.println("tickets = "+tickets--);
        }
    }
}
class ThreadDemo
{
    public static void main(String[] args)
    {
        //将Runnable接口的子类Sell传递给Thread的构造函数，并启动线程
        new Thread(new Sell()).start();
    }
}

实现方式与继承方式的区别

其实Thread类同样也是实现了Runnable接口，所以我们要的只是run方法，那么我们只要实现Runnable接口即可，这样避免了单继承的局限性，我们在实现Runnable接口的同时还可以继承其他的类，扩展了功能

线程权限问题

线程安全问题--同步

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误

class Sell implements Runnable
{
    private int tickets = 10;

    //实现Runnable接口的run方法
    public void run()
    {
        while(tickets > 0)
        {
            try{Thread.sleep(500);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"..tickets = "+(--tickets));
        }
    }
}

当我们让线程操作共享数据时，暂停一会，可以发现，每个线程很容易-1剩余票数的错误

解决方法

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不能参与进来执行

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

synchronized(对象)

{

需要被同步的代码

}

synchronized void show()

{

函数内容

}

class Sell implements Runnable
{
    private int tickets = 10;

    //实现Runnable接口的run方法
    public void run()
    {
        //加入锁，使代码同步
        synchronized(this)
        {
            while(tickets > 0)
            {
                try{Thread.sleep(500);}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"..tickets = "+(--tickets));
            }
        }
    }
}

我们可以看到，即使中途有睡眠过程，也不再出现错误票数，当然这个例子有一些问题，虽然保证了安全，却只能让一个线程完成操作，解决方法很简单，在while循环内设置判断语句，再加锁即可

对象如同锁，持有锁的线程可以在同步中执行

没有持有锁的线程即使获取了cpu的执行权，也无法执行同步代码

如果同步函数被静态修饰后，如何使用锁？

通过验证，发现不再是this，因为静态方法中也不可以定义this

静态进入内存时，内存中没有本类对象，但是一定有该类的对应的字节码文件对象 类名.class，该对象的类型是Class

所以静态的同步方法是，使用该方法所在类的字节码对象作为锁，即类名.class

class Tickets
{
    static int tickets = 10;
    public static void sell()
    {
        //类对象作为锁
        synchronized(Selling.class)
        {
            if(tickets > 0)
            {
                try{Thread.sleep(500);}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"..tickets = "+(--tickets));
            }
        }
    }
}

class Selling implements Runnable
{
    //实现Runnable接口的run方法
    public void run()
    {
        while(Tickets.tickets> 0)
        {
            Tickets.sell();
        }
    }
}

同步的前提：

1. 必须要有两个或两个以上的线程
2. 必须要多个线程使用同一个锁

同步的利弊

好处：解决了多线程的安全问题

弊端：多个线程需要判断锁，较为消耗资源

加入同步之后线程的状态如下

如何编写多线程

1. 明确哪些代码是多线程运行代码
2. 明确共享数据
3. 明确多线程运行代码中哪些语句是操作共享数据的

死锁

死锁其实就是同步中嵌套同步

class A implements Runnable
{
    String a = "a";

    public void run()
    {
        while(true)
        {
            //A抢占A锁
            synchronized(A.class)
            {
                System.out.println("A get 1");
                //A抢占B锁
                synchronized(B.class)
                {
                    System.out.println("A get 2");
                    System.out.println("A:"+a);
                }
            }
        }
    }
}

class B implements Runnable
{
    String b = "b";

    public void run()
    {
        while(true)
        {
            //B抢占B锁
            synchronized(B.class)
            {
                System.out.println("B get 1");
                //B抢占A锁
                synchronized(A.class)
                {
                    System.out.println("B get 2");
                    System.out.println("B:"+b);
                }
            }
        }
    }
}
class DeadlockDemo
{
    public static void main(String[] args)
    {
        new Thread(new A()).start();
        new Thread(new B()).start();
    }
}

结果如下，A和B都在等待对方释放资源（对应的锁）