Java的进程和多线程

​
​

活动地址：优快云21天学习挑战赛

1.进程

1.1定义

进程是计算机程序的一次运行活动，如听音乐。
它同时是系统进行资源分配和调度的基本单位。
进程存在于内存，占用系统资源。而程序，是指编译好的二进制文件，存放于磁盘之中，不占用系统资源。当进程对应程序执行结束，进程结束，系统自动回收进程所使用的资源。

1.2运用

计算机使用多道程序设计技术，即一台计算机允许使用多个独立的程序同时进入内存，在内存中可以互相穿插进行。使得产生多进程同时运行的假象。
在多道程序设计技术中CPU周期被划分为长度相同的微小时间片，一秒可执行10亿条指令，在每个时间片中操作系统内核分配CPU去处理一个进程。多时间片，多进程。
​

2.多线程

2.1定义

线程即在一个进程中运行的执行单元。
每个进程至少会有一个线程。
如当网易云音乐起动时，会产生进程，该进程又会创建一些线程辅助听歌使用。
多线程指一个进程在执行过程中产生多个相互独立线程，同时这些线程可以并发执行。

2.2创建

方法一：继承Thread类

（1）继承java.lang包中的Thread类的run()方法，在实现多线程的代码。无直接返回结果。不适合用于需要返回线程执行结果的业务场景
步骤：

定义一个子类MyThread继承线程类java.lang.Thread，
重写run()方法
创建MyThread类的对象
调用线程对象的start()方法启动线程
启动后还是执行run方法的

import java.lang.Thread;
public class Main{
   public static void main(String []args){
  //创建线程对象
  MyThread My=new MyThread();
  //开启线程
  My.start();
  while(true){
   System.out.println("主线程的执行");
}
}
}
class MyThread extends Thread{
   public void run(){
   while(true){
   System.out.println("多线程的执行");
}
}
}

注意事项：若不调用start()方法则是普通的重写方法run()
此方法编程简单，无法继承其他类，不利于扩展。

方法二：实现Runnable接口

（2）实现java.lang.Runnable接口，在run()方法中实现多线程代码。无直接返回结果。不适合用于需要返回线程执行结果的业务场景
步骤：

定义一个线程任务类MyRunnable实现Runnable接口，
重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理。
调用线程对象的start()方法启动线程

import java.lang.Runnable;
public class Main{
public static void main(String[]args){
    MyThread Mu=new MyThread();
    //创建线程对象
    Thread t1=new Thread(Mu);
    //开启线程启动run()方法  
    t1.start();
    while(true){
   System.out.println("主线程的使用");
}    
}
}
class MyThread implement Runnable{
     public void run(){
     while(true){
     System.out.println("多线程的实现");
}
}
}

此方法线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强，只是变成多一层对象包装，如果有线程执行结果不可以直接返回。
方案二：
实现Runnable接口(匿名内部类形式)
步骤：

可以创建Runnable的匿名内部类对象。
交给Thread处理。
调用线程对象的start()启动线程。    

方法三：实现Callable接口

（3）实现java.util.concurrent.Callable接口，重写call()方法，并使用Future接口获取call(）方法返回的结果
步骤：

定义类实现Callable接口，重写call方法，封装要做的事情。
用FutureTask把Callable对象封装成线程任务对象。
把线程任务对象交给Thread处理。
调用Thread的start方法启动线程，执行任务
线程执行完毕后、
通过FutureTask的get方法去获取任务执行的结果。

import java.util.concurrent.*;
//定义接口实现类
class MyThread implements Callable<Object>
{
public Object call () throws Exception{
 int i=0;
 while(i++<5){
  System.out.println(Thread.currentThread().getName()+"的call方法在运行");
}
return i;
}
}
public class Main{
public static void main(String []args) throws InterruptedException,ExecutionException{
   //创建实例对象
   MyThread Mu=new MyThread();
   //封装MyThread类
   FutureTask<Object> f1=new FutureTask<>(Mu);
   //创建线程对象
   Thread t1=new Thread(f1,"thread");
   t1.start();
   //FutureTask对象管理返回值
   System.out.println(Thread.currentThread().getName()+"的返回结果"+f1.get());
   int a=0;
   while(a++,5){
      System.out.println("主线程方法运行");
}  
}
}

此方法线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强，可以获取线程执行结束后的结果，编码较为复杂