多线程_基本操作

什么是多线程：

　　进程：正在运行的程序，QQ 360 ......

       线程：就是进程中一条执行程序的执行路径，一个程序至少有一条执行路径。（360中的杀毒 电脑体检 电脑清理 同时运行的话就需要开启多条路径）

　　每个线程都有自己需要运行的内容，而这些内容可以称为线程要执行的任务。

　　开启多线程是为了同时运行多部分代码。

　　好处：解决了多部分需要同时运行的问题

　　弊端：如果线程过多，会导致效率很低（因为程序的执行都是CPU做着随机 快速切换来完成的）

　　JVM在启动时，就有着多个线程启动

　　在多线程运行过程中，如有线程抛出了异常，那么该线程会停止运行（出栈），但是并不影响其他线程的正常运行。

线程的四种状态：

创建线程：

　　方法一：继承Thread类

　　方法二：实现Runnable接口

　　分析：创建线程的目的是为了开辟一条执行路径，让线程去运行指定的代码（执行路径的任务），实现和其他线程同时执行任务。

　　　　　JVM创建的主线程任务都定义在了mian方法中；自定义的线程任务将要封装在Thread类的run方法中。

　　方法一的步骤：1：继承Thread类   2：重写run方法（封装任务）  3：实例化Thread类的子类对象   4：调用start方法开启线程（这个方法会调用run方法来执行任务）

class Text{
    public static void main(String[] args) {
        aThread Dome=new aThread();
        Dome.start();
        System.out.println(Thread.currentThread().getName());
    }
}
class aThread extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

currentThread()是一个静态方法，它返回的是当前正在运行线程的这个对象，然后调用getName方法返回这个线程的名字；

名字是Thread-编号（从0开始），主函数的名字就是main。

Thread类中有个接收String类型参数的构造方法，我们传入的数据可以自定义线程的名字。如下代码：

class aThread implements Runnable{
    aThread(String a){
        super(a);
    }
    public void run(){
        System.out.println(this.getName());
    }
}

　　如果一个子类已经有了父类，但是它需要开启多线程来执行任务，那么就要用到Runnable这个接口来扩展该子类的功能（避免了java的单继承局限性）

　　Runnable这个接口只有一个run一个抽象方法，所以Runnable接口的出现仅仅是为了用run封装任务而存在的；而且Thread类也实现了Runnable接口

　　

　　方法二的步骤：1：实现Runnable接口　2：重写run方法（封装任务）　3：创建Thread线程a  创建Runnable子类对象t　　

　　　　　　　　　4：将t作为参数传递给a（Thread有个构造方法是用来接收Runnable类型参数的；因为任务都封装在了Runnbale子类的run方法中，

　　　　　　　　　　　在开启线程的时候就要明确线程的任务，否则Thread会调用自己的run方法，Runnbale子类中的任务将永远不会被执行到）

　　　　　　　　　5：开启线程（start）

class Text{
    public static void main(String[] args) {
        aThread t=new aThread();
        Thread a=new Thread(t);
        a.start();
        System.out.println(Thread.currentThread().getName());
    }
}
class aThread implements Runnable{
    
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

　　实现Runnable接口的好处：1.将任务从Thread子类中分离出来，进行单独的封装；按照面向对象的思想将任务封装成了对象

　　　　　　　　　　　　　　 2.避免了JAVA单继承的局限性

多线程安全问题：

　　原因： 1.多个线程操作共享数据

　　           2.操作共享数据的代码有多条

                  当一个线程在执行共享数据的多条代码时，有其他的线程参与进来，就会导致线程安全问题的产生。

　　例：

class Text{
    public static void main(String[] args) {
        aThread t=new aThread();
        Thread a=new Thread(t);
        Thread a1=new Thread(t);
        Thread a2=new Thread(t);
        Thread a3=new Thread(t);
        a.start();
        a1.start();
        a2.start();
        a3.start();
    }
}
class aThread implements Runnable{
    private int mun=100;
    public void run(){
        while(mun>0){
            try{Thread.sleep(5);}catch(InterruptedException e){}
            /*为了能够看得清楚，让线程冻结，sleep会抛出异常由于Runnable接口并没有抛出异常
            ，所以其子类也不能抛，只能try catch去捕捉异常。*/
            System.out.println(Thread.currentThread().getName()+"....."+mun--);
        }/*运行的结果中会出项这样的情况Thread-3.....42  Thread-0.....42
                （如果是卖票的话我们可以理解为这两个线程都卖了42号这个票，这是不允许的）*/
    }
}

解决问题：

　　思路：当有线程操作共享数据的代码块时，不允许其他线程参与进来，即同步（简单说就是给共享数据的代码块安个锁，线程进来的时候都要判断一下是不是有别的线程正在操作共享数据代码块）

　　同步的好处：解决了安全问题

　　同步的弊端：相对而言效率降低了（因为每次都需要判断锁）

　　注意：这几个线程一定要使用同一个锁

　　方法一：同步代码块

　　方法二：同步函数

　　关键字：synchronized

　　

　　实现方法一（同步代码块）：

class Text{
    public static void main(String[] args) {
        aThread t=new aThread();
        Thread a=new Thread(t);
        Thread a1=new Thread(t);
        Thread a2=new Thread(t);
        Thread a3=new Thread(t);
        a.start();
        a1.start();
        a2.start();
        a3.start();
    }
}
class aThread implements Runnable{
    private int mun=100;
    private Object obj=new Object();
    public void run(){
        while(mun>0){
            synchronized(obj){
                if(mun<=0)return;
                try{Thread.sleep(5);}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+"....."+mun--);
            }    
        }
    }
}

同步代码块的锁是可以自定义的，这里的锁我自定义的是Obiect类的对象obj

　　实现方法二（同步函数）：

class Text{
    public static void main(String[] args) {
        aThread t=new aThread();
        Thread a=new Thread(t);
        Thread a1=new Thread(t);
        Thread a2=new Thread(t);
        Thread a3=new Thread(t);
        a.start();
        a1.start();
        a2.start();
        a3.start();
    }
}
class aThread implements Runnable{
    private int mun=100;
    17     public void run(){
        while(mun>0)
        show();
    }
    public synchronized void show(){
            if(mun<=0)return;
            try{Thread.sleep(5);}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+"....."+mun--);    
    }
}

同步函数的锁是固定的this

静态同步函数的锁，是这个函数所属的字节码对象（class文件）

　　建议使用同步代码块

死锁：

　　同步的嵌套，有两把锁，都拿着对方的锁，导致代码无法继续进行下去。

class Text{
    public static void main(String[] args) {
        aThread a=new aThread(true);
        aThread a1=new aThread(false);
        Thread t=new Thread(a);
        Thread t1=new Thread(a1);
        t.start();
        t1.start();
    }
}
class aThread implements Runnable{
    private boolean flag;
    aThread(boolean flag){
        this.flag=flag;
    }
    public void run(){
        if(flag){
            synchronized(suo.suo1){
                System.out.println("我是if锁1");
                synchronized(suo.suo2){
                    System.out.println("我是if锁2");    
                }
            }
        }else{
            synchronized(suo.suo2){
                System.out.println("我是elsef锁2");
                synchronized(suo.suo1){
                    System.out.println("我是else锁1");    
                }
            }
        }
    }    
}
class suo{
    public static final Object suo1=new Object();
    public static final Object suo2=new Object();
}

懒汉式在多线程中的应用：

　　因为懒汉式并没有直接实例化对象，在线程0判断了if语句后进入临时阻塞状态，线程1也进入了进来，这就导致了实例化不唯一

实例化不唯一问题的示例代码：

public class Text1 {

    public static void main(String[] args) {
        Ab a=new Ab();
        Ab b=new Ab();
        a.start();
        b.start();
        try{Thread.sleep(10);}catch(InterruptedException e){}
        System.out.print(a.get()==b.get());
    }
}
class Single{
    private static Single a=null;
    private Single(){
    }
    static Single  getSingle(){
        if(a==null){
            try{Thread.sleep(10);}catch(InterruptedException e){}
            a=new Single();
        }
        return  a;
    }
}
class Ab extends Thread{
    private Single a;
    public void run(){
        a=Single.getSingle();
    }
    Single get(){
        return a;
    }
}

多试几次输出的结果就会出现false

　　

　　解决问题（同步）（饿汉式代码应该如下修改）：

class Single{
    private static Single a=null;
    private Single(){
    }
    static Single  getSingle(){
        if(a==null){
            synchronized (Single.class){
                if(a==null){
                    a=new Single();
               }
            }
        }
        return  a;
    }
}

注意：在原有的饿汉式代码中多加了一个if判断,是为了提高效率，不然的还线程总是会去判断锁，效率下降，这也是不时用同步函数的原因。

　　　加了同步，是为了解决安全问题。

所以在开发的时候还是使用饿汉式好