浅学 “ Java多线程 ”

我们之前学习的程序在没有跳转语句时，从上到下依次执行，那么我们现在需要设计一个程序，可以一边打游戏，一边听歌，如何实现？

要解决上述问题，我们需要使用多进程或者多线程来解决

并发与并行

并发：指两个或多个事件在同一时间段内发生

并行：指两个或多个事件在同一时刻发生(同时发生)

线程与进程

进程 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；是资源分配的基本单位；系统运行一个程序，即是一个进程从创建、运行到消亡的过程

线程 是进程中的一个执行单位，是独立调度的基本单位，负责当前进程中程序的执行，一个进程中至少有一个线程

一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序

一个程序运行后至少有一个进程，一个进程可以包含多个进程

线程调度

分时调度

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

抢占式调度

优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的是抢占式调度‘

主线程

JVM执行main方法，main方法会进行到栈内存，JVM会找操作系统开辟一条main方法，通向cpu的执行路径，cpu就可以通过这个路径执行main方法，而这个路径有一个名字，叫main(主)线程

 public static void main(String[] args){
     person p1=new person("张三");
     p1.run();
     person p2=new person("李四");
     p2.run();
 }

public class person {
    private String name;

    public void run(){
        for(int i=0;i<10;i++)
            System.out.println(name+"--->"+i);
    }
    public person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建多线程程序的第一种方式

Java使用Java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或者子类的实例，每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行提来代表这段程序流。Java通过继承Thread类来创建并启动多线程的步骤

1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了
线程需要完成的任务，因此把run()方法称为线程执行体
2.创建Thread子类的实例,即创建了线程对象
3.调用线程对象的start()方法来启动该线程

public static void main(String[] args){
        //创建Thread类的子类对象
        MyThread mt=new MyThread();
        //调用Thread类中的方法start方法，开启新的线程，执行run方法
        //void start() 结果是两个线程并发的运行
        mt.start();
        for(int i=0;i<10;i++)
            System.out.println("main:"+i);

    }

    public class MyThread extends Thread {
    @Override
    public void run(){
        for(int i=0;i<10;i++)
            System.out.println("run:"+i);
    }
}

根据输出结果，我们可以知道多线程是随机性打印结果

Thread类的常用方法

获取线程名称

/*
      获取线程的名称：
      1.使用Thread类中的方法getName()
         String getName() 返回该线程的名称
      2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
         static Thread currentThread()返回对当前正在执行的线程对象的引用

      主线程的名称：Main
      新线程：Thread-0  Thread-1
    */
    public static void main(String[] args){
        //创建Thread类的子类对象
        MyThread mt=new MyThread();
        //调用Thread类中的方法start方法，开启新的线程，执行run方法
        //void start() 结果是两个线程并发的运行
        mt.start();

        new MyThread().start();
        //获取主线程名称
        System.out.println(Thread.currentThread().getName());

    }

public class MyThread extends Thread {
    //重写Thread类中的run方法，设置线程任务
    @Override
    public void run(){
        //获取线程名称
        //方法1：
        //String name = getName();
        //System.out.println(name);

        //方法2：
        //Thread thread = Thread.currentThread();
        //System.out.println(thread);

       // String name = thread.getName();
       // System.out.println(name);

        //方法3：链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

设置线程名称

public static void main(String[] args){
       //开启多线程
       MyThread mt=new MyThread();
        mt.setName("张三");
        mt.start();
       new MyThread("李四").start();
    }

public class MyThread extends Thread {
    //重写Thread类中的run方法，设置线程任务
    public MyThread(){

    }
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run(){
        //获取线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

sleep

 /*
     public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
     毫秒数结束之后，线程继续执行
    */
    public static void main(String[] args){
        //模拟秒表
        for(int i=1;i<=60;i++)
        {
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);

            }catch(InterruptedException e){
                e.printStackTrace();

            }
        }
    }

创建多线程程序的第二种方式

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

java.lang.Runnable

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法

java.lang.Thread类的构造方法

 Thread(Runnable target) 分配新的Thread对象
 Thread(Runnable target,String name)分配新的Thread对象

实现步骤：

1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性
一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其它的类
实现了Runnable接口，还可以继承其它的类，实现其它的接口
2.增强了程序的扩展性，降低了程序的耦合性（解耦）
实现了Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）
实现类中，重写了run方法；用来设置线程任务
创建Thread类对象，调用start方法；开启新线程

匿名内部类方式实现线程的创建

匿名：没有名字
内部类：写在其它类内部的类

匿名内部类作用：简化代码
把子类继承父类，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

 格式：
 new 父类/接口(){
     重复父类/接口中的方法

public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run(){
                for(int i=0;i<20;i++)
                    System.out.println(Thread.currentThread().getName()+"-->"+"abc");
            }
        }.start();
        //线程的接口Runnable
        //Runnable r=new RunnableImpl();//多态
        Runnable r= new Runnable(){
            @Override
            public void run() {
                for(int i=0;i<20;i++)
                    System.out.println(Thread.currentThread().getName()+"-->"+"efg");
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法，设置线程任务
            @Override
            public void run(){
                for(int i=0;i<20;i++)
                    System.out.println(Thread.currentThread().getName()+"-->"+"123");
            }
        }).start();
    }

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码，程序每次运行结果和单线程运行的结果是一样的，而且其它的变量的值也和预期的是一样的，就是线程安全的