原创

Java基础面试题(进程和线程的区别,以及进程的线程的使用)

进程和线程的区别
进程:是并发执行的程序在执行过程中分配和管理资源的基本单位,是一个动态概念,竞争计算机系统资源的基本单位 
线程:是进程的一个执行单元,是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。
一个程序至少一个进程,一个进程至少一个线程。
线程的创建方式 
第一种方法
继承Thread类
重写thread类里面的run()方法
创建线程的子类对象
调用start方法启动线程

public class MyThread extends Thread {  
  public void run() {
   System.out.println("MyThread.run()");
  }
}

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();


第二种方法:
定义类实现Runnable接口
实现接口里的run()方法,也就是将线程要执行的任务封装在run方法中
创建线程对象,然后将实现Runnable接口的类作为创建线程对象的参数传入
调用线程对象的start方法,启动线程

public class Test {
private static int money;
public int getMoney(){
return money;
}
public void saveMoney(int m){
//保证线程的安全
synchronized (this) {
System.out.println("存钱后的总金额:"+(money+=m));
}
}
public void drawMoney(int m){
synchronized (this) {
Test test = new Test();
if (test.getMoney()<=0) {
System.out.println("没得钱,取个pi");
}else {
System.out.println("取钱后剩的总金额:"+(money-=m));
}
}
}
public static void main(String[] args) {
Test1 m1 = new Test1();
Test2 w = new Test2();
Thread t1 = new Thread(m1);
Thread t2 = new Thread(m1);
Thread t3 = new Thread(m1);
Thread t4 = new Thread(w);
Thread t5 = new Thread(w);
Thread t6 = new Thread(w);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
public class Test1 implements Runnable{
private Test test = new Test();
public void run() {
int m = 100;
int i=0;
while (i<5) {
test.saveMoney(m);
i++;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test2 implements Runnable{
private Test test = new Test();
public void run() {
int m = 100;
int i=0;
while (i<5) {
test.drawMoney(m);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
}
}

第三种:

实现Callable接口通过FutureTask包装器来创建Thread线程  

public interface Callable<V>   { 
V call() throws Exception;
}
public class SomeCallable<V> extends OtherClass implements Callable<V> {
@Override
public V call() throws Exception {
// TODO Auto-generated method stub
return null;
}
}
Callable<V> oneCallable = new SomeCallable<V>();
//由Callable<Integer>创建一个FutureTask<Integer>对象:
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);
//注释:FutureTask<Integer>是一个包装器,它通过接受Callable<Integer>来创建,它同时实现了Future和Runnable接口。
//由FutureTask<Integer>创建一个Thread对象:
Thread oneThread = new Thread(oneTask);
oneThread.start();
//至此,一个线程就创建完成了。

第四种:

ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,有了这种特征就不需要再为了得到返回值而大费周折了。而且自己实现了也可能漏洞百出。所以在这里就不在给出实例

如有不多的地方多多指教



正文到此结束