线程与进程的关系:
进程 --运行中的程序。进程有如下特征:
1).独立性。拥有自己的资源,拥有自己独立的内存区。
通常来说,一个进程的内存空间,是不允许其他进程访问的。
但像Windows,如A进程可以通过某种方式修改其他进程的内存值。
2).动态性。程序是静止的,运行起来才叫进程。
3).并发性。一个操作系统可以同时“并发(concurrent)”运行多个进程。
线程 --进程中的“并发(concurrent)”执行流,轻量级进程。
线程与进程的典型区别:Process(进程)是有独立内存的,因此创建Process的成本比创建线程的成本高。
什么是“并发”?什么是“并行”?
1)并发:即使只有一个CPU,多个进程、或多个线程在CPU上【快速轮换】的执行。在同一个时刻,只有与CPU个数相同的进程真正在执行,其他进程都处于等待状态。--对用户来说,[感觉]是多个进程在同时执行。
2)并行(Parallel):必须有一个以上的cpu,在同一时刻,至少有与CPU个数相同的进程[真正]在执行。
多线程的好处:1)功能上类似多进程;
2)创建成本低,效率高;
3)所有线程共享进程的内存,因此线程之间的通信非常方便。
Java创建多线程的方法(3种):(注意 Java默认有个main方法主线程的执行体)
启动线程:调用Thread对象的start()方法,千万不要调用run()方法。就是普通方法的调用,就不会启动多线程了。
a)继承Thread,重写一个run()方法,---这个run方法就是线程执行体(就是该线程将要做的事情)。
举列说明1:
public class Test extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// Thread.currentThread()用于获取当前正在运行的线程
System.out.println(Thread.currentThread().getName() + ",i=" + i);
}
}
public static void main(String[] args) {
new Test().start();// 创建匿名实例并启动线程
}
}
b)实现Runnable接口,重写run方法。--推荐举例说明2:
public class Test implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// Thread.currentThread()用于获取当前正在运行的线程
System.out.println(Thread.currentThread().getName() + ",i=" + i);
}
}
public static void main(String[] args) {
new Thread(new Test()).start();// 这里把Runnable对象包装成Thread对象。
}
}
c)实现Callable(就是Runnable增强版),重写call方法(有返回值,可以声明抛出异常)。举例说明3:
public class Test implements Callable<Integer> {
@Override
public Integer call() throws Exception {
for (int i = 0; i < 100; i++) {
// Thread.currentThread()用于获取当前正在运行的线程
System.out.println(Thread.currentThread().getName() + ",i=" + i);
}
return 100;
}
public static void main(String[] args) {
// 将Callable包装成FutureTask,再包装成Thread,最后启动线程
new Thread(new FutureTask<Integer>(new Test())).start();
;
}
}
创建线程方式的对比,创建线程的方式可分为2类:
1。继承Thread类;2。实现Runnable或Callable接口。
总的来说,实现接口的方式更好,原因如下:
1.实现接口之后,依然可以继承其他类;但如果继承了Thread类,就无法继承其他类了。
2.实现接口时,可以让多个线程共享同一个Runnable对象。可以更好的实现代码与数据的分离,形成更清晰的逻辑。
线程的状态(当调用start()方法之后,只是启动了线程,线程并不会立即执行):
新建:刚刚创建出来的Thread对象。
就绪:调用start()之后,处于就绪状态。
从就绪到运行:是不可控的,靠线程调度器来分配。
从就绪到运行:靠线程调度器来分配(yield()方法可以主动的让出cpu,进入就绪状态)。
阻塞:调用sleep()、IO阻塞、等待同步锁、等待通知等将进入阻塞Blocked状态;sleep()时间到、IO阻塞解除、获取同步锁、收到通知后等将进入就绪状态。
正常死亡:线程执行体执行完成;遇到了未捕获的异常。
控制线程的方法:
Join线程:启动一条线程,多条线程并发执行,被joined线程必须先执行完成。
举例说明:
class JoinThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// Thread.currentThread()用于获取当前正在运行的线程
System.out.println(Thread.currentThread().getName() + ",i=" + i);
}
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
JoinThread jt1 = new JoinThread();
JoinThread jt2 = new JoinThread();
for (int i = 0; i < 100; i++) {
System.out.println("主线程正在执行:i=" + i);
if (i == 20) {
// 主线程执行到此处时,必须等到jt1、jt2执行完后,主线程才能继续向下执行。
jt1.start();
// 將jt1这条进程join进来, 等待jt1线程终止。
jt1.join();
jt2.start();
jt2.join();
}
}
}
}
后台线程(Daemon Thread):又称守护线程、精灵线程。如果所有的前台线程结束,它会自动死亡。JVM的垃圾回收器就是一个典型的后台进程。调用Thread对象的setDaemon(true)方法可将指定线程设置为后台线程。
线程暂停:Thread.sleep(100):让线程暂停100ms,并且进入阻塞状态。--推荐(更稳定)
线程让步:Thread.yield():让线程让出cpu,并进入就绪状态。
改变线程的优先级:优先级越高,线程会获得更多的执行机会。
举例说明:(优先级高的先执行)
class PriorityThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// Thread.currentThread()用于获取当前正在运行的线程
System.out.println(Thread.currentThread().getName() + ",i=" + i);
}
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
PriorityThread jt1 = new PriorityThread();
jt1.setPriority(Thread.MIN_PRIORITY);
PriorityThread jt2 = new PriorityThread();
jt2.setPriority(Thread.MAX_PRIORITY);
jt1.start();
jt2.start();
System.out.println("~~~~~~主线程结束~~~~~");
}
}