JAVA并发编程（一）-线程的基本认识

一、进程与线程

1、 进程

（1）进程是计算机中运行的程序的实例。它是系统进行资源分配和调度的基本单位。
（2）每个进程都有独立的内存空间，包括代码、数据和堆栈。一个进程无法直接访问其他进程的内存。
（3）进程之间的通信通常需要通过进程间通信（IPC）的机制，如管道、消息队列、共享内存等。
（4）进程拥有自己的独立地址空间，当一个进程崩溃时，通常不会影响其他进程。

2、线程

（1）线程是进程内的一个独立执行流。一个进程可以包含多个线程，它们共享进程的资源。
（2）线程有自己的堆栈和局部变量，但共享进程的全局变量和静态变量。
（3）多线程可以提高程序的并发性，允许多个任务同时执行。
由于线程共享进程的地址空间，因此线程之间的通信和数据共享相对容易，但也需要注意同步和互斥的问题。

3、进程和线程的关系

（1）一个进程可以包含多个线程，这些线程共享相同的资源和地址空间。
（2）线程是进程的一部分，是进程内的执行单元。

二、异步调用

需要等待结果返回，才能继续进行的就是同步

  public static void main(String[] args) {

        log.debug("读取文件操作");//同步


        log.debug("do otherthing.........");


    }

不需要等待结果返回，就能继续运行就是异步

    public static void main(String[] args) {

        new Thread(() -> {
            log.debug("读取文件操作");//异步
        }).start();


        log.debug("do otherthing.........");


    }

三、创建线程

1、直接使用Thread

public static void main(String[] args) {

        Thread createThread = new Thread(() -> log.debug("create thread"));
        createThread.setName("thread1");
        createThread.start();

    }

2、FutureTask配合Thread

  public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<Integer> task = new FutureTask<>(() -> {
            log.debug("调用线程");
            return 100;
        });

        Thread t1 = new Thread(task, "t1");

        t1.start();

        log.debug("{}", task.get());


    }

四、线程运行原理

@Slf4j(topic = "test")
public class test {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

       method1(10);


    }
    private static void method1(int x){
        int y=x+1;
        Object m=method2();
        System.out.println(m);
    }

    private static Object method2(){
        return new Object();
    }

}

首先要对test进行类加载
首先会对类中方法的字节码加载JVM的方法区中

当执行main方法之后，main线程栈中会有一条main栈帧加载到当中

因为main方法中只有一行代码，所以这里就会把这一行代码放到程序计数器中，让CPU去执行

这时候调用的是method1这个方法，所以这里又会有一个method1栈帧压到线程栈当中去。

执行method1中的代码int y=x+1，会改变栈帧中的局部变量。

然后就执行下一行代码，调用method2，那么就会又有一个method2的栈帧压到线程栈当中去了。

然后这里执行method2中的方法的时候，需要去新建对象，这里就会在堆中新建了对象，然后赋值给n。

当method2执行完之后，根据返回地址就会把对应新建的对象返回给m，并释放掉method2的栈帧。

如此类推，当method1执行完成后也是这样释放掉

五、线程常见方法

六、sleep方法

public static void sleep(long millis) throws InterruptedException

通常会使用TimeUnit来提高可读性

TimeUnit.SECONDS.sleep(10);

七、yield方法

没有执行yield让步的时候可以看到两个线程执行的次数都是差不多的

   public static void main(String[] args)  {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                for (; ; ) {
                    //Thread.yield();//线程t1让步
                    System.out.println("----->t1" + count++);
                }
            }
        });
        thread.setName("t1");
        thread.start();


        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                for (; ; ) {
                    System.out.println("      t2----->" + count++);
                }
            }
        });
        thread2.setName("t2");
        thread2.start();
        
    }

当线程t1让步的时候就会发现明显的差距

八、join方法

  join() 方法是 Thread 类提供的一个方法，用于等待调用该方法的线程执行完成。换句话说，join() 方法会阻塞调用它的线程，直到被调用的线程执行完成，才会继续执行。

    static int r;


   public static void main(String[] args) {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                log.debug("开始");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                r = 10;
       			//thread.join();
                log.debug("结束");
            }
        });
        thread.join();
        thread.start();
        log.debug("r={}", r);
    }

  这里我们可以看到虽然会等到thread-1的线程结束，但主线程在打印r的时候为0，而且是在thread-1结束前打印出来的。

  如果我们这里需要主线程等待thread-1线程结束后，才打印r的结果出来，这样子我们就需要加上join（）方法。
执行的效果如下

九、interrupt方法

1、打断正在正常运行的线程

 public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
          while(true){
              
          }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
        log.debug("打断标记:{}", thread.isInterrupted());
    }

打断标记为true

  这里程序会知道有打断的消息，但不会对当前线程进行打断，所以线程还没有结束。

  那么如果我们想收到打断后就结束线程，那就需要改成这样子。当线程处于被打断的时候，我们就直接退出了。

public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
          while(true){
              boolean interrupted = Thread.currentThread().isInterrupted();
              if(interrupted){
                  log.debug("被打断了，跳出循环");
                  break;
              }
          }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
        log.debug("打断标记:{}", thread.isInterrupted());
    }

2、打断正在阻塞的线程

   public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("1");
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
        log.debug("打断标记:{}", thread.isInterrupted());
    }

打断标记为false