做微信封面模板下载网站/全网引流推广 价格

进程和线程：

（1）什么是进程

         1）例如记事本酷狗音乐等软件，程序启动运行后，操作系统会给其分配系统资源和内存空间；进程是系统层面的资源调度和分配单位；

         2）进程就是在内存中运行的应用程序，进程都有自己独立的内存空间，该进程在执行过程中可以独享该块内存空间，所以一个进程出问题，不会影响其他进程；

         3）大部分简单的应用程序只会对应一个进程；某些复杂的如杀毒软件、数据库软件等是由多个进程组成的；

         4）早期的操作系统是单任务的，同时只能运行一个程序；现在的操作系统大多支持多程序同时执行，这就是进程在起作用。

（2）什么是线程

         1） 线程是进程的一个执行单元，其负责当前进程中某部分程序的执行。一个进程中至少有一个线程，一个进程也可以运行多个线程，多个线程间可共享数据；

         2.1）多个线程是共享某进程的内存等资源的，一个线程没有独立的运行空间，一个线程出问题，会影响其他线程的正常运行；所以，多进程的程序比多线程的程序更健壮；但是，因为多进程切换时，资源损耗较大，所以多进程比多线程效率低。

         2.2）与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

（3）进程和线程的区别

（摘自：https://blog.csdn.net/ThinkWon/article/details/102021274）

         线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少包含一个线程。

         根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位

         资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

         包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

         内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的

         影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

         执行过程：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。

（4）线程提升效率的原因

【多线程能提高运行效率的前提】是 线程本身不会一直占用CPU且不占CPU的空闲时间大于线程切换时间，否则在线程时间运行效率变低，在线程需100%占用CPU时，CPU利用率也不会得到提升。即线程是一种压榨CPU的一种方式，使CPU尽量一刻不得闲，从而提升效率。如果，CPU已经达到了极限，再使用线程是起不到作用的。

Thread类创建线程：

（1）Thread类的构造方法：

        ●Thread(Runnable target)，正是通过Runnable接口创建线程时需要用到的构造方法；

（2）Thread类常用方法

        ●不同功能的线程的区别就在于run()方法中的代码不同；

（3）Thread类也是实现了Runnable接口的

（4）Thread类创建线程示例程序

Java规定一个类必须继承Thread类（或实现Runnable接口）才能成为一个线程类，Java就是这样设计和规定的。

简单示例：其中通过 MyThread myThread = new MyThread(); 实例化线程类得到一个线程，主方法又是一个线程；

（1）创建一个类继承Thread类，得到线程类；（2）线程类添加run()方法，在run方法中添加线程相关代码；（3）实例化线程类对象，调用start()方法启动线程；

// 一个类需要继承Thread类，才能成为一个线程类
class MyThread extends Thread{// 所有和线程相关的代码都写在run()方法内public void run(){System.out.println("线程正在执行");	}
}public class ThreadTest {public static void main(String[] aegs){MyThread myThread = new MyThread();// 一个线程不能多次调用start()方法，即不能多次启动。其不会编译报错，但会产生运行时错误myThread.start();System.out.println("主方法的线程");		}
}

……………………………………………………

简单示例：同上；

（1）创建一个类继承Thread类，得到线程类；（2）线程类添加run()方法；（3）线程类添加有参构造方法，通过调用Thread类的有参构造，得线程类的有参构造，该有参构造方法可以指定线程的name；（4）调用线程类的有参构造，MyThread mythread1 = new MyThread("线程1")；创建线程；线程类每实例化一次就得到一个实际的线程；（5）在线程类中可以直接调用getName()方法得到当前线程的name；

class MyThread extends Thread{public MyThread(){}// 定义一个构造方法，通过调用父类Thread类的构造方法，给线程指定一个namepublic MyThread(String name){super(name);}// 所有和线程相关的代码都写在run()方法内public void run(){for(int i = 1;i<=10;i++){// 因为当前类是直接继承Thread类的，所以可以直接使用getName()方法，而无需通过实例化对象等方式调用System.out.println(getName()+"执行第"+i+"次;");}}	
}public class ThreadTest {public static void main(String[] args) {// 一个类继承了Thread类，并实现run方法后，该类便成了一个线程类，该类的每实例化一个对象，就是新创建了一个实际的线程。MyThread mythread1 = new MyThread("线程1");MyThread mythread2 = new MyThread("线程2");mythread1.start();mythread2.start();	}
}

Runnable接口创建线程

这种方式更常用，因为Java不支持多继承。

（1）Runnable接口说明

（2）示例程序

本例是最容易理解的形式：

可以发现（1）Printrunnable类实现Runnable接口，并实现run()方法，成为线程类；（2）通过Thread.currentThread().getName()获取线程name，因为Runnable接口中没有getNamt()方法，getName()方法实在Thread类的，所以通过Thread类去获取线程名；（3）实例化线程类对象，通过Thread的有参构造：Thread(Runnable target)，得到最终的线程对象；

注：通过（3）可以发现，只有Thread类的对象，或者Thread子类的实例对象，才是最终的可以启动的进程对象；一个实现了Runnable接口的类的实例对象，可以理解为是具备了线程潜质的对象，但其并不是一个可以启动的线程对象，其还是要通过Thread thread = new Thread(Runnable target)来得到最终的线程对象。

// PrintRunnable类实现Runnable接口
class PrintRunnable implements Runnable{//int i = 1;    // 多个线程处理同一个资源的情况@Overridepublic void run() {int i = 1;while(i <= 10){// 此时，不能直接使用getName()获取线程name了，因为getName()方法是Thread类里面的；System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));}	}
}public class Test {public static void main(String[] args) {PrintRunnable pr1 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t1 = new Thread(pr1);t1.start();// PrintRunnable pr2 = new PrintRunnable();PrintRunnable pr2 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t2 = new Thread(pr2);t2.start();}
}

输出结果：

Thread-1正在运行1
Thread-0正在运行1
Thread-0正在运行2
Thread-1正在运行2
Thread-0正在运行3
Thread-1正在运行3
Thread-0正在运行4
Thread-1正在运行4
Thread-1正在运行5
Thread-1正在运行6
Thread-1正在运行7
Thread-1正在运行8
Thread-1正在运行9
Thread-1正在运行10
Thread-0正在运行5
Thread-0正在运行6
Thread-0正在运行7
Thread-0正在运行8
Thread-0正在运行9
Thread-0正在运行10

……………………………………………………

对上示例改造如下：线程类只实例化一次，通过多次调用Thread thread = new Thread(Runnable target)得到多个线程；

// PrintRunnable类实现Runnable接口
class PrintRunnable implements Runnable{//int i = 1;    // 多个线程处理同一个资源的情况@Overridepublic void run() {int i = 1;while(i <= 10){// 此时，不能直接使用getName()获取线程name了，因为getName()方法是Thread类里面的；System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));}	}
}public class Test {public static void main(String[] args) {PrintRunnable pr1 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t1 = new Thread(pr1);t1.start();// PrintRunnable pr2 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t2 = new Thread(pr1);t2.start();}
}

输出结果：由结果也可发现，同一个线程类的实例化对象，如果多次调用Thread thread = new Thread(Runnable target)，也会得到不同的线程

Thread-1正在运行1
Thread-0正在运行1
Thread-0正在运行2
Thread-0正在运行3
Thread-0正在运行4
Thread-0正在运行5
Thread-1正在运行2
Thread-1正在运行3
Thread-1正在运行4
Thread-1正在运行5
Thread-1正在运行6
Thread-1正在运行7
Thread-1正在运行8
Thread-1正在运行9
Thread-1正在运行10
Thread-0正在运行6
Thread-0正在运行7
Thread-0正在运行8
Thread-0正在运行9
Thread-0正在运行10

……………………………………………………

对上示例改造如下：把循环变量i转移到循环外

// PrintRunnable类实现Runnable接口
class PrintRunnable implements Runnable{int i = 1;    // 多个线程处理同一个资源的情况@Overridepublic void run() {//int i = 1;while(i <= 10){// 此时，不能直接使用getName()获取线程name了，因为getName()方法是Thread类里面的；System.out.println(Thread.currentThread().getName()+"正在运行"+(i++));}	}
}public class Test {public static void main(String[] args) {PrintRunnable pr1 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t1 = new Thread(pr1);t1.start();// PrintRunnable pr2 = new PrintRunnable();// Thread类的构造方法中有这种形式：Thread(Runnable target)Thread t2 = new Thread(pr1);t2.start();}
}

输出结果：多个线程处理同一个资源的情况，这是多个线程处理同一个资源的情况。之所以是多个线程处理同一个资源，是因为上面程序中，两个Thread t1 = new Thread(pr1)和Thread t2 = new Thread(pr1)使用了同一个Runnable类型的对象。

Thread-0正在运行1
Thread-1正在运行1
Thread-0正在运行2
Thread-1正在运行3
Thread-0正在运行4
Thread-0正在运行6
Thread-1正在运行5
Thread-0正在运行7
Thread-0正在运行9
Thread-0正在运行10
Thread-1正在运行8