java的系统进程 java进程是什么

1、java多线程的定义

• 首先理解什么是java的程序，线程，进程
  1，程序:一段静态的代码，一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体，是应用软件执行的蓝本。
  2，进程:是程序的一次动态执行，它对应着从代码加载，执行至执行完毕的一个完整的过程，是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映了一个程序在一定的数据集上运行的全部动态过程。通过进程控制块(PCB)唯一的标识某个进程。同时进程占据着相应的资源（例如包括cpu的使用 ，轮转时间以及一些其它设备的权限）。是系统进行资源分配和调度的一个独立单位。 程序和进程之间的主要区别在于：
  
  进程的基本状态:
  1、就绪（Ready）状态
  当进程已分配到除CPU以外的所有必要资源后，只要在获得CPU，便可立即执行，进程这时的状态就称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将他们排成一个队列，称为就绪队列。
  2、执行状态
  进程已获得CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态；再多处理机系统中，则有多个进程处于执行状态。
  3、阻塞状态
  正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即程序的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态。

三种进程之间的转换图：

• 什么是java的多线程
  java 的多线程是进程在进行计算机的内存，io，cpu资源之间的抢占

2、如何实现多线程

1、继承Thread类

2、实现Runable接口

虽然Thread类可以实现多线程的主题类定义，但是它有一个问题，java具有单继承局限，正因为如此针对于类的继承都应该是回避的问题，那么多线程也一样，为了解决单继承的局限性，

class MyThread2 implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
	}
}

-2.1 在接口里面任何方法都是public定义的权限，不存在默认的权限。
那么只需要让一个类实现Runnable接口即可，并且也需要覆写run（）方法。

与Thread类相比，此时的MyThread类在结构上与之前是没有区别的，但是有一点是有区别的，实现了Runnable接口的类可以覆盖run方法，但是没有start方法。
不管何种情况下，如果要启动多线程，一定要依靠Thread类完成，在Thread定于有以下的构造方法：

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

这个构造方法接受的是Runnable 对象

package com.yangwishe64.threadAndProcess;

public class ThreadRunnable {
	public static void main(String[] args) {
		ThreadRunnable1 t1=new ThreadRunnable1("这是进程A");
		ThreadRunnable1 t2=new ThreadRunnable1("这是进程B");
		ThreadRunnable1 t3=new ThreadRunnable1("这是进程C");
		new Thread(t1).start();
		new Thread(t2).start();
		new Thread(t3).start();
	}
}
class ThreadRunnable1  implements Runnable{
	String name;
	public ThreadRunnable1(String name) {
		this.name=name;
	}
	@Override
	public void run() {
		for(int i=0;i<200;i++) {
			System.out.println(this.name+i);
		}
	}
}

2、多线程两种实现方式的区别

首先要明确的是，使用Runnable接口与Thread类相比，解决了单继承的局限性
至少这一点就已经下了死定义----如果要使用Runnable接口
首先来观察下Thread类的定义

public
class Thread implements Runnable {
}

此时整个的定义结构看起来非常像代理设计模式，如果是代理设计模式，那么客户端里调用的方法应该是接口里面提供的方法，那么也应该是run（）才是。

使用Runnable接口可以比Thread更好的描述数据共享这一概念。数据共享指多个线程访问同一资源的操作

先看以下的代码

package com.yangwishe64.threadAndProcess;

public class MyThreadTest {
	public static void main(String[] args) {
		MyThread m=new MyThread("");
		new Thread(m).start();
		new Thread(m).start();
		new Thread(m).start();
	}
}
class MyThread implements Runnable{
	String ticket;
	int ticketnum=10;
	public MyThread(String ticket) {
		this.ticket=ticket;
	}
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			if(ticketnum>0) {
			System.out.println("还剩的票数："+ticketnum--);
			}
		}
	}
}

运行结果

uml图

问：请解释Thread类与Runnable接口实现多线程的区别

• Thread类事项了Runnable接口，使用Runnable接口实现多线程避免单继承的局限性，
• Runnable接口实现的多线程可以比Thread更能体现出数据共享的概念

第三种实现方法

使用Runnable接口实现的多线程可以避免单继承局限，的确很好，但是有一个问题，Runnable里面的run（）方法并不能返回操作结果（因为public void run（）），为了解决这样的矛盾，提供了新的接口java.util.Callable

package com.yangwishe64.threadAndProcess;

import java.util.concurrent.Callable;

public class CallableDemo {
	public static void main(String[] args) throws Exception {
		ThreadTest t1=new ThreadTest();
		System.out.println(t1.call());;
	}
}
class ThreadTest implements Callable{
	@Override
	public String call() throws Exception {
		int ticketnum=10;
		for(int i=0;i<100;i++) {
				if(ticketnum>0) {
				System.out.println("还剩的票数："+ticketnum--);
				}
			}
		return "票已经卖光了";
	}
}

此时观察Thread类里面发现没有直接支持Callable接口的多线程应用。
从jdk1.5开始提供有java.util.concurrent.FutureTask类，这个类负责Callable接口对象操作，
结构为
public class FutureTask extends Object implements RunnableFuture
public interface RunnableFuture extends Runnable,Future
在FutureTask类里面定义有如下的构造方法：public FutureTask(Callable< V> callable)
接受的目的只有一个，那么就是取得call（）方法的返回结果

package com.yangwishe64.threadAndProcess;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableDemo {
	public static void main(String[] args) throws Exception {
		ThreadTest t1=new ThreadTest();
		ThreadTest t2=new ThreadTest();
		
		FutureTask<String> futureTask1=new FutureTask<>(t1);
		FutureTask<String> futureTask2=new FutureTask<>(t2);
		new Thread(futureTask1).start();
		new Thread(futureTask2).start();
		System.out.println("线程A的返回结果"+futureTask1.get());
		System.out.println("线程B的返回结果"+futureTask2.get());
		
	}
}
class ThreadTest implements Callable{
	@Override
	public String call() throws Exception {
		int ticketnum=10;
		for(int i=0;i<100;i++) {
				if(ticketnum>0) {
				System.out.println("还剩的票数："+ticketnum--);
				}
			}
		return "票已经卖光了";
	}
}

返回结果