2019-06-03 Java学习日记 day24 多线程

多线程

　　线程是程序执行的一台路径，一个进程中可以包含多条线程

　　多线程并发执行可以提高程序的效率，可以同时完成多项工作

多线程的应用背景

　　红蜘蛛同时共享屏幕给多个电脑

　　迅雷开启多条线程一起下载

　　QQ同时和多个人一起视频

　　服务器同时处理多个客户端请求

多线程并行和并发

　　并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行（需要多核CPU）

　　并发是指两个任务都请求运行，而处理器只能接受一个任务，就把这两个任务轮流进行，由于时间间隔较短，使人感觉两个任务都在运行

　　比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行

　　如果用一台电脑我先给甲发个信息，然后立刻再给乙发信息，然后再跟甲聊，再跟乙聊。这就叫并发

java程序运行原理和jvm的启动

　　*java命令启动java虚拟机，启动jvm，等于启动了一个应用程序，也就是启动了一个进程，该进程会自动启动一个 “ 主线程 ”，然后主线程去调用某个类的 main 方法

　　*jvm启动至少启动了垃圾回收线程和主线程，所以是多线程的

多线程程序实现

　1.　继承Thread

　　　　定义类继承Thread

　　　　重写run方法

　　　　把新线程要做的是写在run方法中

　　　　创建线程对象

　　　　开启新线程，内部会自动执行run方法

public class demo1_thread {

    public static void main(String[] args) {
        mythread mt1 =new mythread(); //创建thread类的子类对象
        mt1.start();  //开启线程
        
        for(int i=0;i<1000;i++){
            System.out.println("bbbbb");
            
        }

    }

}
class mythread extends Thread{  //继承thread
    public void run(){            //重写run方法
        for(int i=0;i<1000;i++){
            System.out.println("aaaaaaaaaa");
        }
    }
}

　2.　实现runnable

　　　　定义类显示Runnable接口

　　　　实现run方法

　　　　把新线程要做的事写在run方法中

　　　　创建自定义的Runnable的子类对象

　　　　创建Thread对象，传入Runnable

　　　　调用start（）开启新线程，内部会自动调用Runnable的run方法

public class demo2_Runnnbale {
        public static void main (String args []){
            myrunnbale mr =new myrunnbale();  //创建runnable的子类对象
            new Thread(mr).start();            //将其当做参数传递给thread的构造函数,并开启线程
            
            for (int i = 0; i < 1000; i++) {
                System.out.println("cc");
            }
        }
}
class myrunnbale implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("aaaaaaaaaaaaaa");
        }
        
    }
    
    
}

实现Runnable的原理

　　看Thread类的构造函数，传递了Runnable接口的引用

　　通过init（）方法找到传递的target给成员变量的target赋值

　　查看run方法，发现run方法中有判断，如果target不为null就会太哦用Runnable接口子类对象的run方法

两种方式的区别

　　1.继承Thread：由于子类重写了Thread类的run（），方太哦用start（）时，直接找子类的run（）方法

　　2.实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start（）调用run（）方法时内部成员变量Runnable引用是否为空，不为空编译时看的siRunnable的run（），运行时执行的狮子类的run（）方法

继承Thread：

　　好处是：可以直接使用Thread类中的方法，代码简单

　　弊端是：如果已经有父类，就不能用这种方法

实现Runnable接口：

　　好处是：即使自己定义的县城类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的

　　弊端是：不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂

匿名内部类实现线程

　　1.继承Thread方法　

　　2.实现Runnable方法

public class demo3_Thread {

    public static void main(String[] args) {
        new Thread(){          //继承Thread方法
            public void run(){    //重写run方法
                for (int i = 0; i < 3000; i++) {
                    System.out.println("aaaaaaaaa");
                }
            }
        }.start();  //开启线程
        
        
        new Thread(new Runnable(){
            public void run(){
                for (int i = 0; i < 3000; i++) {
                    System.out.println("bbb");
                }
            }
        }).start();
    }

}

获取名字

　　1.通过geyName（）方法获取线程对象的名字

设置名字

　　2.通过构造方法函数可以传入String类型的名字

　　通过setName（String）方法可以设置线程对象的名字

public class demo1_Name {
    public static void main (String args[]){
        new Thread("大哥"){
            public void run(){
                System.out.println(this.getName()+"aaaaaaaa");
            }
        }.start();
        
        new Thread(){
            public void run(){
                this.setName("战三");
                System.out.println(this.getName()+"bb");
            }
        }.start();
        
        Thread t1= new Thread("大哥"){
            public void run(){
                System.out.println(this.getName()+"aaaaaaaa");
            }
        };
        t1.setName("李");
        t1.start();
    }
}

获取当前线程的对象

　　Thread.currentThread（），主线程也可以获取

public class demo2_currentthread {

    public static void main(String[] args) {
        new Thread("毛毛"){
            public void run (){
                System.out.println(getName()+"...aaaaaaa");
            }
        }.start();
        
        
        new Thread(new Runnable(){
            public void run(){
                //Thread.currentThread()获取当前正在执行的线程
                System.out.println(Thread.currentThread().getName()+"...bb");
            }
        }).start();
        
        Thread.currentThread().setName("主线程");
        System.out.println(Thread.currentThread().getName());
    }

}

 

休眠线程

　　Thread.sleep（毫秒，纳秒），控制当前线程休眠若干毫秒1秒 =1000 * 1000 * 1000纳秒  1000000000

public class demo3_seelp {

    public static void main(String[] args) throws InterruptedException {
        //demo1();
        new Thread(){
            public void run(){
                for (int i = 20; i >=0; i--) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"...a");
                }
            }
        }.start();
        new Thread(){
            public void run(){
                for (int i = 20; i >=0; i--) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"..bb");
                }
            }
        }.start();

    }

    public static void demo1() throws InterruptedException {
        for(int i=20;i>=0;i--){
            Thread.sleep(1000);
            System.out.println("倒计时"+i+"秒");
        }
    }

}

守护线程

　　setDaemon（），设置一个线程为守护线程，该线程不会单独执行，当其他飞守护线程都执行结束后，自动退出

public class demo4_daemon {

    public static void main(String[] args) {
        Thread t1 =new Thread(){
            public void run(){
                for (int i = 0; i < 2; i++) {
                    System.out.println(getName()+"..aaaaaaaa");
                }
            }
        };
        Thread t2 =new Thread(){
            public void run(){
                for (int i = 0; i < 50; i++) {
                    System.out.println(getName()+"..bb");
                }
            }
        };
        t2.setDaemon(true); //当传入true就是意味着设置为守护线程
        t1.start();
        t2.start();
    }

}

加入线程

　　join（），当前线程暂停，等待指定的线程执行结束后，当前线程在继续

　　join（int），可以等待指定的毫秒之后继续

public class demo5_Join {

    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()+"...aaaaaaaaa");
                }
            }
        };
        Thread t2 =new Thread(){
            public void run (){
                for(int i=0; i<10 ;i++){
                    if(i==2){
                        try {
                            t1.join(1);
                        } catch (InterruptedException e) {
                            
                            e.printStackTrace();
                        }
                    }
                    System.out.println(getName()+"...bb");
                }
            }
        };
        
        t1.start();
        t2.start();
    }

}

礼让线程

yield让出cpu

设置线程的优先级

　　setPriority（） 设置线程的优先级

N1.setPriority(Thread.MIN_PRIORITY);            //设置最大的线程优先级
N2.setPriority(Thread.MAX_PRIORITY);           //设置最小线程优先级

同步代码块

什么情况下需要同步

　　当多线程并发，有多段代码同时执行是，我们希望某一段代码执行的过程中cpu不要切换到其他线程工作，这是就需要同步

　　如果两端代码是同步的，那么同一时间值执行一段，在一段代码每执行结束之前，不会执行另一端代码

同步代码块

　　使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块

　　多个同步代码块如果使用相同的锁对象，那么他们就是同步的

public class test_sybchronized {

    public static void main(String[] args) {
    final pritner p1=new pritner();
    
        
        new Thread(){
            public void run(){
                while(true){
                p1.print1();    
                }
            }
        }.start();
        new Thread(){
            public void run(){
                while(true){
                p1.print2();    
                }
            }
        }.start();

    }

}
class pritner{
demo d=new demo();
    public void print1(){
        synchronized (d) {
        
        System.out.println("学习");
    }
        }
    public void print2(){
        System.out.println("学校");
    }
}

class demo{}

同步方法

*使用synchronized 关键字修饰一个方法，该方法中所有的代码都是同步的

public class test2_sybchronized {

    public static void main(String[] args) {
    final pritner2 p1=new pritner2();
    
        
        new Thread(){
            public void run(){
                while(true){
                p1.print1();    
                }
            }
        }.start();
        new Thread(){
            public void run(){
                while(true){
                p1.print2();    
                }
            }
        }.start();

    }

}
class pritner2{

    //非静态放入同步方法的锁对象是this
    //静态的锁不方法的锁对象是：该类的字节码对象
    public synchronized void print1(){
        
        System.out.print("学");
        System.out.print("习");
        System.out.print("的");
        System.out.print("心");
        System.out.print("
");
    
        }
    public void print2(){
        synchronized (this) {        
        System.out.print("学");
        System.out.print("校");
        System.out.print("的");
        System.out.print("路");
        System.out.print("上");
        System.out.print("
");
         }
       }
    }

线程安全问题

　　多线程并发操作同一数据时，就有可能出现线程安全问题

　　使用同步技术可以解决这种问题，把操作数据的代码进行同步，不要多个线程一起操作

public class test2_ticket {

    public static void main(String[] args) {
        new ticket().start();
        new ticket().start();
        new ticket().start();
        new ticket().start();

    }

}
class ticket extends Thread{
    private static int ticket =100;
    
    public void run(){
        while(true){
            synchronized (ticket.class) {    
            if(ticket <=0){
                break;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(getName() + "...这是第" + ticket-- + "号票");
        }
            }
    }
}

死锁

多线程同步的时候，如果同步代码嵌套，使用相同锁，就有可能出现死锁

public class test3_ {
    
    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();

    }

}