JAVA多线程编程
基础概念:
程序是为完成特定任务、用某种语言编写的一组指令的集合。指一段静态的代码,是一个静态的概念。
进程是具有一定独立功能程序的运行过程,是系统进行资源分配和调度的一个独立单位,重点在系统调度和单独的单位,也就是说进程是可以独立运行的一段程序。
线程是进程中的一个独立执行线索,是进程中的一个实体,是CPU调度和分派的基本单位,是比进程更小的能独立运行的基本单位,线程自己基本上不拥有系统资源。在运行时,只是暂用一些计数器、寄存器和栈
线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止
启动进程的方法:
public class T0 {
public static void main(String[] args) throws IOException {
ProcessBuilder pb = new ProcessBuilder("cmd","/c","ifconfig/all");
Process p = pb.start();
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String temp = null;
while((temp = br.readLine())!=null)
System.out.println(temp);
}
}
进程的三大特征:独立性、动态性、并发性
僵尸进程、孤儿进程
僵尸进程是当子进程比父进程先结束,而父进程又没有回收子进程,释放子进程占用的资源,此时子进程将成为一个僵尸进程。如果父进程先退出 ,子进程被init接管,子进程退出后init会回收其占用的相关资源 —是对系统资源的浪费,必须解决。
——————分割线——————————————————————
孤儿进程是一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。—没有什么危害。
并行与并发(重点)
并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。
——————分割线——————————————————————
并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS(每秒钟处理的事务数)或者QPS(每秒钟处理的请求数)来反应这个系统的处理能力。
主线程
线程是进程中的一个实体,用来描述进程的执行,它负责执行包括在进程的地址空间中的代码。创建一个进程时,它的第一个线程称为主线程,它由系统自动生成。
&&主线程是产生其他子线程的;通常主线程最后执行完成,因为主线程执行各种关闭动作,但是不绝对。
线程和进程的区别
进程和线程最大的区别在于:进程是由操作系统来控制的,而线程是由进程来控制的。
多线程
多线程方式是指在一个程序中存在多个线程,每一个线程执行一个独立的任务,多个线程可以并发执行。
线程的编程4种实现方法
1、继承Thread类
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。
启动线程的唯一方法就是通过Thread类的start()实例方法,不能直接调用run()方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。
public class T1 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.start();
}
}
class MyThread extends Thread{
public void run() {
for(int i = 0;i<10;i++) {
System.out.println("Thread---");
try {
//使当前正在执行的线程休眠等待500ms
Thread.sleep(200);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
2、实现Runnable接口
class RightRunnable implements Runnable{
public void run(){
for(int i=0;i<50;i++)
System.out.println(Thread.currentThread().getName()+"说:右手慢动作重播!");
}
}
//启动方法
//启动通过实现Runnable接口定义的线程对象,不能直接使用Runnable r=new RightRunnable();
Thread t2=new Thread(new RightRunnable());
t2.start();
3、使用Callable和Future接口创建线程
创建Callable接口的实现类,并实现call()方法。并使用FutureTask类来包Callable实现类的对象,且以此FutureTask对象作为Thread对象的target来创建线程。
public class MyCallable implements Callable<Integer>{
int begin=0;
int end=0;
public MyCallable(int begin, int end){
this.begin=begin;
this.end=end;
}
public Integer call()throws Exception{
int res=0;
for(int k=begin; k<=end; k++)
res+=k;
System.out.println(Thread.currentThread()+"---"+res);
return res;
}
}
FutureTask[] arr=new FutureTask[10];
for(int i=0;i<10;i++){
arr[i]=new FutureTask<>(new MyCallable(i*10+1,(i+1)*10));
Thread t=new Thread(arr[i]);
t.start();
}
int res=0;
for(int i=0;i<arr.length;i++)
res+=((Integer)arr[i].get());
System.out.println("计算结果为:"+res);
4、使用线程池创建线程
线程池这里关系到一个享元模式–享元模式可以百度“享元模式 菜鸟教程”进行详细学习。
享元模式Flyweight Pattern主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式。
优点:大大减少对象的创建,降低系统内存的使用,以提高程序的执行效率。
缺点:提高了系统的复杂度,需要分离出外部状态和内部状态,而且外部状态具有固有化的性质,不应该随着内部。状态的变化而变化,否则会造成系统的混乱。
public class T0 {
public static void main(String[] args) {
//创建一个 固定大小为 3 的线程池;
ExecutorService es = Executors.newFixedThreadPool(10);
Future[] fs = new Future[10];
for(int i = 0;i<fs.length;i++) {
Callable<Integer> call = new MyCallable(i*10+1, (i+1)*10);
fs[i] = es.submit(call);
}
int res = 0;
for(int i=0;i<fs.length;i++) {
Object obj = fs[i].get();
if(obj!=null&&obj instanceof Object)
res+=(Integer)obj;
}
es.shutdown();
System.out.println("main"+res);
}
}
class MyCallable implements Callable<Integer>{
private int begin;
private int end;
public MyCallable(int begin, int end) {
super();
this.begin = begin;
this.end = end;
}
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
int res = 0;
for(int i = begin;i<=end;i++)
res+=i;
return res;
}
}
之前 线程池创建线程 有点小问题 第一个问题是:第六行代码 最后的范围有误(已经改正)
第二个问题 第三行 线程池 数应该是 :10;
最后一个问题:倒数第五行 i值应该小于并且等于 end 。否则输出的值 少了最后的值
以上问题 都已经改正