Java进行多线程编程？（lambda表达式~）

本文标题：Java进行多线程编程？那么，Java为啥不学学如何进程多进程编程呢？？原因在于：Java圈子中不提倡多进程编程~~

接下来，我们来写一个最为基础/入门的HelloWord程序来感受如何进行多线程~~
Java标准库提供了一个类Thread能够表示一个线程~

public class MyThread extends Thread {
    //继承：创建一个类MyThread，继承标准库的Thread
    @Override
    public void run(){//重写，子类重写父类的方法
        System.out.println("Hello Word");
    }

    public static void main(String[] args) {
        //先创建MyThread实列，t的引用实际上是指向子类的实列
        Thread t=new MyThread();
        //启动线程，再进程中搞了另外一个流水线，新的流水线开始并发的执行另外一个逻辑了~
        t.start();
    }
}

在上述的代码段中，主要涉及到两个线程：

1. main方法所对应的线程（一个进程中至少得有一个线程），也可也称为主线程；
2. 通过t.start()创建的新的线程

通过右键运行main方法，其实是idea对应的进程，创建了一个新的Java进程，这个Java进程来执行咱们自己写的代码，这个Java进程里就有两个线程，一个是main线程，另一个是t线程~

调整代码，具体仔细看一下，体会一下：“每个线程都是一个独立的执行流~”；

public class MyThread extends Thread {
    //继承：创建一个类MyThread，继承标准库的Thread
    @Override
    public void run(){//重写，子类重写父类的方法
//        System.out.println("Hello Word");
        
        //死循环
        while (true){
            System.out.println("hello  t ---->t线程");
        }
    }

    public static void main(String[] args) {
        //先创建MyThread实列，t的引用实际上是指向子类的实列
        Thread t=new MyThread();
        //启动线程，再进程中搞了另外一个流水线，新的流水线开始并发的执行另外一个逻辑了~
        t.start();
        
        //死循环
        while (true){
            System.out.println("hello  main  ---->main线程");
        }
    }
}

在上述的代码中，t线程和main线程都写了一个while(true)的死循环，按道理来说，一进入while(true)就会死循环了，但是，实际的代码运行情况却不是这样的~~

截取自运行结果部分示意图~

观看运行结果，显而易见的可以得到：交替打印~，此时看到的效果：hello  t ---->t线程和hello  main  ---->main线程都能打印出来，通过t.start()另外启动了一个执行流，而新的执行流（新的线程）来执行        while (true){System.out.println("hello  t ---->t线程"); }，因此这段代码与        while (true){System.out.println("hello  main  ---->main线程"); }看起来在同时执行；

线程是能够交替运行的，但是打印出来的结果肯定是有先后的！！因为两个线程往同样一个控制台上控制，同一个控制台必须得顺序输出~！

通过上述代码的运行结果，我们可以看到这两个线程就算再同时执行，先打印几个hello  t ---->t线程，再打印几个hello  main  ---->main线程…………，如果是单个线程的话，此时就是只能打印其中一个，看不到另外一个！

当然，我们对上述代码的main方法做出简单更改！

public class MyThread extends Thread {
    //继承：创建一个类MyThread，继承标准库的Thread
    @Override
    public void run(){//重写，子类重写父类的方法
//        System.out.println("Hello Word");

        //死循环
        while (true){
            System.out.println("hello  t ---->t线程");
        }
    }

    public static void main(String[] args) {
        //先创建MyThread实列，t的引用实际上是指向子类的实列
        Thread t=new MyThread();
        //启动线程，再进程中搞了另外一个流水线，新的流水线开始并发的执行另外一个逻辑了~
        //start()会创建新的线程
        //t.start();
        //run不好创建新的线程，run是在main线程中执行的
        t.run();

        //死循环
        while (true){
            System.out.println("hello  main  ---->main线程");
        }
    }
}

代码的运行结果为：

此处，代码没有创建其他的线程，两个死循环都在同一个线程中，执行到第一个死循环后，代码就出不来了，第二个死循环就进不去了，因此，代码会一直在打印：hello  t ---->t线程

在MyThread中：

public class MyThread extends Thread {
    //继承：创建一个类MyThread，继承标准库的Thread
    @Override
    public void run(){//重写，子类重写父类的方法
//        System.out.println("Hello Word");

        //死循环
        while (true){
            System.out.println("hello  t ---->t线程");
        }
    }
}

run()方法：线程的入口方法；

run()方法不是一个随便的方法，是重写了父类的方法~

这种重写一般就是：功能的扩展

一般这样的重写方法是不需要咱们自己手动调用的，已经有其他代码来调用了~如果我们随便写了run2()方法，这样的方法没有在t.start()中被调用，是无法自动执行的~

t.start()方法：调用操作系统的API，创建新的线程，从而新的线程里调用t.run()方法

上述的代码打印太快，不利于查看，可以加thread.sleep(1000),1000是指1000毫秒等于1秒

sleep是Thread的静态方法（通过类名调用）。（报错的话，抛出异常即可）

当然，sleep(1000)仅之休眠一秒，之后的打印结果也不是严格意义上的交替，每一秒过后，是先打印main线程，还是先打印t线程，都是不确定的，因为多个线程在CPU上调度执行的顺序是不确定的（随机）；

线程虽然有优先级，但是，这个优先级对于系统来说，只是“建议”

program---->jdk---->bin---->jconsloe.exe应用程序，使用这个jdk提供的工具，就能够给我们查看出Java进程里的线程详情~~

jconsloe只能分析Java进程，不能识别非Java进程，主注意：idea是用Java写的，jconsloe也是用Java写的（占用两个进程，需要注意区分-----》看名字）

当然，有的同学运行jconsloe发现进程列表是空的，大概率是权限问题，右键----》以管理员方式运行即可~（确保代码在运行中，才能看到~）

上述的代码是：使用继承Thread，重写run()方法的方式来创建线程（使用Thread的run()描述线程的入口）

接下来，我们使用实现Runnable，通过重写run方法的方式来创建线程（使用Runnable的interface来描述线程的入口~）

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hello t---->t线程");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable runnable=new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();

        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

对于上述代码的运行结果，大家可自行尝试（交替打印）

3.继承Thread，使用匿名内部类（内部类：定义在类里面的类）

public class Main1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(){
            @Override
            public void run(){
                while (true){
                    System.out.println("hello t---->t线程");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        
        t.start();
        while (true){
            System.out.println("hello main---->main线程");
            Thread.sleep(1000);
        }
    }
}

4.实现Runnable使用匿名内部类

public class Main1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(){
            @Override
            public void run(){
                while (true){
                    System.out.println("hello t---->t线程");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        
        t.start();
        while (true){
            System.out.println("hello main---->main线程");
            Thread.sleep(1000);
        }
    }
}

需要注意的是：{ }放到哪里，就算针对哪个类创建的匿名内部类

当然，创建线程最推荐的写法：使用lambda表达式！！最简单最直观的写法（前面几种可以不记）

lambda表达式：本质就是一个匿名函数！！（没有名字的函数，这种一般是一次性的），Java里面函数（方法）是无法脱离类的，在Java里面lambda就相当于一个列外！！

lambda表达式的基本写法：()->{ }

()小括号里面放参数，如果只有一个参数（）可省略

{ }大括号里面放函数，写各种Java代码，如果只有一行代码，{ }可省略

那么，我们来看一下具体的写法吧~

public class ThreadDemos {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello t---->t线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        t.start();
        while (true){
            System.out.println("hello main---->main线程");
            Thread.sleep(1000);
        }
    }
}

上述的代码即为lambda表达式的写法（强调~）

更多关于lambda表达式的资料，请详见：百度安全验证