文章目录
进程和线程
进程
就是正在运行的程序。也就是代表了程序锁占用的内存区域。
- 独立性:进程是系统中独立存在的实体,它可以拥有自己的独立的资源,每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。
- 动态性:进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念,进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。
- 并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。
线程
- 线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一个进程可以开启多个线程。
- 多线程扩展了多进程的概念,使得同一个进程可以同时并发处理多个任务。
- 简而言之,一个程序运行后至少一个进程,一个进程里包含多个线程。
- 如果一个进程只有一个线程,这种程序被称为单线程。
- 如果一个进程中有多条执行路径被称为多线程程序。
进程和线程的关系
- 从上图中可以看出一个操作系统中可以有多个进程,一个进程中可以有多个线程
- 每个进程有自己独立的内存,每个线程共享一个进程中的内存,每个线程又有自己独立的内存。
- 想使用线程技术,得先有进程,进程的创建是OS创建的,一般都是c或者c++语言完成的。
线程的特性
- 随机性
线程状态
线程生命周期
- 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();
- 就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;
- 运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
- 阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被CPU调用以进入到运行状态;
- 根据阻塞产生的原因不同,阻塞状态又可以分为三种:
- 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
- 同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
- 其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
- 关闭状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
多线程的创建
一.继承Thread
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。Start()方法是一个native方法,它将通知底层操作系统,最终由操作系统启动一个新线程,操作系统将执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。
模拟开启多个线程,每个线程调用run()方法
常用方法
String getName()
返回该线程的名称。
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
void setName(String name)
改变线程名称,使之与参数 name 相同。
static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
void start()
使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
Thread(String name)
分配新的 Thread 对象。
二.实现Runnable接口
如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口。
常用方法
void run()
使用实现接口 Runnable 的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的 run 方法。
三.Executors 创建线程池的方式
- 创建线程池的工具类:Executors.newFixedThreadPool(int n);可以创建包含最多n个线程的线程池对象
- 创建好的线程池对象:ExecutorService
使用pool.excute()来讲线程池中的线程以多线程的方式启动,每次调用都会将一个线程对象加入到就绪队列之中
这个线程池对象负责: 新建/启动/关闭线程,而我们主要负责的是自定义的业务
注意:线程池是不关闭的,实现的效果就是线程池中线程对象的随取随用,这样就避免了频繁的创建与销毁线程,不会造成资源浪费 - 合理利用线程池可以拥有的优势:
- 降低系统的资源消耗:减少系统创建与销毁线程对象的次数,每个线程都可以重复利用,执行多次任务
- 提高响应速度:当任务到达时,任务可以不用等待线程创建就能立即执行
- 提高线程的可管理性:可以根据系统的承受能力,调整线程池中线程的数目.
防止因为创建多个线程消耗过多的内存导致服务器的崩溃.
- 【每个线程大约需要1MB的内存,线程开的越多,消耗的内存也就越大,最后死机】
api
ExecutorService
execute(Runnable任务对象) 把任务丢到线程池
Executors 辅助创建线程池的工具类
newFixedThreadPool(5) 最多5个线程的线程池
newCachedThreadPool() 足够多的线程,使任务不必等待
newSingleThreadExecutor() 只有一个线程的线程池
测试
package game;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test_Pool {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);//2个线程的线程池
// pool = Executors.newCachedThreadPool();
// pool = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100; i++) {
pool.execute(new R1(i));//放入池中,并等待执行,底层会自动反射run()
}
}
}
class R1 implements Runnable {
int i ;
public R1(int i) {
this.i=i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+ " : "+i);
}
}
package game;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test6 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newSingleThreadExecutor();
C1 c1 = new C1();
//任务c1放入线程池并行执行
Future<Double> future = pool.submit(c1);
Double r = future.get();//获取结果
System.out.println(r);
pool.shutdown();//关闭任务
}
}
class C1 implements Callable<Double> {
@Override
public Double call() throws Exception {
return Math.random();
}
}
线程锁
多线程数据安全隐患的解决方案
-
出现数据安全问题的原因:多线程程序 + 多个线程拥有共享数据 + 多条语句操作共享数据
-
解决:加锁synchronized同步关键字
- 同步方法【不太常用】,格式:在方法的定义上加synchronized
- 同步代码块,格式:
synchronized(唯一的锁对象){
可能会出现数据不安全问题的所有代码
}
- 注意1:锁对象必须唯一!!!
- 比如:如果是实现接口的方式,只需要创建一个接口实现类对象。而这个对象当做的是目标业务对象,类中定义的锁对象自然也只有一个
- 比如:如果是继承Thread类的方式,我们需要创建多个子类对象作为线程对象
- 那这个时候不同的线程对象间应该共享同一把锁,所以需要把锁设置为静态,被全局所有对象共享
- 而且建议,此种方式使用的锁对象是本类的字节码对象:类名.class
- 注意2:加锁时,同步代码块的范围需要考虑, 不能太大,太大效率太低;也不能太小,太小锁不住
- 注意3:加锁时,锁对象的类型不做限制,只要保证锁对象唯一即可
同步与异步
- 异步:是多个线程抢占资源的效果,不排队,所以效率高,但是数据不安全
- 同步:每次只有一个线程独占资源,排队,所以效率低,但是安全,为了安全必要应该牺牲一部分资源