进程
程序: 是为了完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码
进程是程序的一次动态执行过程
线程
线程是比进程更小的执行单位,线程是进程内部单一的一个顺序控制流。
多线程
多线程,指的是一个进程内的多个任务并发执行;
线程之间回进行cpu资源的抢占。
多线程的实现
三种形式:
1.继承Thread类,
2.实现Runnable接口(推荐)
3.实现Callable接口
继承Thread类
创建类继承Thread
public class Mythread extends Thread{
public Mythread(String name) {
super(name);
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是一个线程");
}
}
测试类
public class Test01 {
public static void main(String[] args) {
Mythread t1 = new Mythread("t1");
t1.start();
}
}
实现Runnable接口
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是一个线程");
}
}
测试类
public class Test02 {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable, "t1");
Thread t2 = new Thread(myRunnable, "t2");
t1.start();
t2.start();
}
}
实现Callable接口
import java.util.concurrent.Callable;
public class Mycallable implements Callable {
@Override
public Object call() throws Exception {
//线程睡眠
Thread.sleep(300);
System.out.println(Thread.currentThread().getName()+"ok");
return "sss";
}
}
测试类
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test03 {
public static void main(String[] args) {
Mycallable mycallable = new Mycallable();
FutureTask task = new FutureTask(mycallable);
Thread t1 = new Thread(task, "t1");
Thread t2 = new Thread(task, "t2");
t1.start();
t2.start();
try {
System.out.println(task.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("main");
}
}
之所以推荐使用Runnable类是因为它可以继承其他类,而继承Thread类的方法就不能再继承其他类了(java是单继承)。Callable接口有很多的方法,但是实现太多复杂。
线程状态
五个状态: 新建状态 new
就绪状态 start 还没有抢占到cpu资源
运行状态 抢占到cpu资源了,执行run方法
阻塞状态 sleep,wait,没获取到锁等因素,线程暂停
死亡状态 正常死亡(run执行完毕)