03java多线程编程的核心技术
1.进程与线程的概念
一个进程管理多个线程,进程是爹妈,管着众多的线程儿子.
开一个QQ,开了一个进程.开了迅雷,开了一个进程.
在QQ这个进程里面,传输文字开了一个线程,传输语音开了一个线程,弹出对话框开了一个线程.
文艺点的:
进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统的基础.
线程,也成为轻量级进程(LightWeight Process,LWP ),是程序执行流的最小单元.线程是程序中一个单一的顺序控制流程.
单个程序中同时运行多个线程完成不同的工作,就是多线程.
进程和线程的关系
线程和进程各自的区别和优势?
- 进程是资源分配的最小单位,线程是程序执行的最小单位
-
进程有自己的独立地址空间,每启动一个进程,系统就会为他们分配地址空间,建立数据表来维护代码块,堆栈段和数据段,这种操作非常昂贵.
而线程是共享进程中的数据的,使用相同的地址空间,因此CPU切换一个线程的花费远比进程小的多,同时创建一个线程的开销也比进程小的多,线程的上下文切换的性能消耗要小于进程. - 线程之间的通信比进程之间的通信要更加方便,同一进程下的线程共享全局变量,静态变量等数据,而进程之间的通信需要以通信的方式(IPC)进行.
- 使用多进程程序更加健壮,多线程程序只要有一个线程死掉,整个进程也就死掉了,而一个进程死掉并不会对另外一个进程造成影响,因为进程有自己的独立的地址空间.
二.同步和异步
对于一次方法的调用来说,
同步方法:
调用一旦开始,就必须等待该方法的调用返回,后续的方法才可以继续执行.
异步方法:
方法一旦调用,就可以立即返回,调用者可以执行后续的方法.
这里的异步方法通常会在另一个线程里真实的执行,而不会妨碍当前线程的执行
三.并行和并发
并行(Parallel):指的是多条垃圾收集线程并行工作,但此时用户线程仍处于等待状态.
并发(Concurrent):指用户线程和垃圾收集线程同时执行,(但不一定是并行的,可能会交替执行),用户程序在继续执行.而垃圾收集程序运行在另一个CPU上.
并行和并发都表示同一时间范围内有两个或多个任务同时在执行,但其在任务调度的时候有区别.
从上图中可以看到，两个任务在执行的时候，并发是没有时间上的重叠的，两个任务是交替执行的，由于切换的非常快，对于外界调用者来说相当于同一时刻多个任务一起执行了；
而并行可以看到时间上是由重叠的，也就是说并行才是真正意义上的同一时刻可以有多个任务同时执行。
四.java实现多线程的方式
一.继承Thread类
package cn.itcast.mutilThread;
/*
* java实现多线程-继承Thread类
* Thread类本身实现了runnable接口,并且持有run方法
* 但是Thread类的run方法主体是空的.
* Thread类的run方法通常是由子类的run方法重写.
*/
public class MutilThread extends Thread {
@Override
public void run() {
while (true) {
System.out.println(this.currentThread().getName());
}
}
public static void main(String[] args) {
MutilThread thread = new MutilThread();
thread.start();// 线程启动的正确方式
MutilThread thread2 = new MutilThread();
thread2.start();// 线程启动的正确方式
}
}
二.实现Runnable接口
package cn.itcast.mutilThread;
public class MutilThread2 implements Runnable{
@Override
public void run() {
System.out.println("123");
}
public static void main(String[] args) {
MutilThread2 mutilThread2 = new MutilThread2();
Thread thread = new Thread(mutilThread2,"t1");
thread.start();
}
}
五.线程安全
线程安全:当多个线程访问某一个类(对象或者方法)时,这个类始终能表现出正确行为,那么这个类(对象或者方法)就是线程安全的.
线程安全就是多线程访问,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问,直到该线程读完,释放了锁,其他线程才可以使用.
这样的话就不会出现数据不一致或者数据被污染的情况.
线程不安全就是不提供访问保护,有可能出现多个线程先后更改数据以至于所得到的数据就是脏数据.
这里的加锁机制常见的比如:synchronized
六.Synchronized修饰符
- Synchronized:可以在任意对象及方法加上锁,而加锁的这段代码称为互斥区或者临界区.
1.不使用Synchronized的实例
package cn.itcast.mutilThread;
public class NoSynchronizedThread extends Thread {
private int count =5;
@Override
public void run() {
count--;
System.out.println(this.currentThread().getName()+"count:"+count);
/*
* 第一次运行的结果:
* thread1count:2
thread3count:2
thread4count:1
thread2count:2
thread5count:0
第二次运行的结果:
thread1count:3
thread2count:3
thread3count:2
thread5count:1
thread4count:0
*/
}
public static void main(String[] args) {
NoSynchronizedThread NoSynchronizedThread = new NoSynchronizedThread();
Thread thread1 = new Thread(NoSynchronizedThread,"thread1");
Thread thread2 =new Thread(NoSynchronizedThread,"thread2");
Thread thread3 =new Thread(NoSynchronizedThread,"thread3");
Thread thread4 =new Thread(NoSynchronizedThread,"thread4");
Thread thread5 =new Thread(NoSynchronizedThread,"thread5");
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
}
}
如果在public void run(){}方法上面加上Synchronized的话,就变成了线程同步的方法,即变成这样public synchronized void fun(){}
运行结果如下:
thread1count:4
thread2count:3
thread3count:2
thread5count:1
thread4count:0
可见加上Synchronized确实能起到同步的作用.
- 总结如下:
- 当多个线程访问MyThread的run方法的时候,如果使用了Synchronized修饰,那么多线程就会以排队的方式进行处理(排队是按照CPU分配的先后顺序而定的.)
- 一个线程想要执行Synchronized修饰的方法里的代码,首先是尝试获得锁,如果拿到锁,执行Synchronized代码体的内容.
- 如果拿不到锁的话,这个线程就会不断的尝试获得这把锁,直到拿到那把锁为止,而且多个线程同时去竞争者这把锁,也就是会出现竞争锁的问题.
七.一个对象有一把锁,多个线程多个锁
下面举一个例子
有一个MultiThread类
- 里面的主方法如下:
public static void main(String[] args) throws Exception {
final MultiThread3 multiThread1 = new MultiThread3();
final MultiThread3 multiThread2 = new MultiThread3();
new Thread(new Runnable() {
@Override
public void run() {
multiThread1.printNum("thread1", "a");
}
}).start();
Thread.sleep(5000);
System.out.println("等待5秒,确保thread1打印完毕");
new Thread(new Runnable() {
@Override
public void run() {
multiThread2.printNum("thread2", "b");
}
}).start();
}
- 需要调用的方法如下:
private int num=200;
public synchronized void printNum(String threadName,String tag){
if ("a".equals(tag)) {
num=num-100;
System.out.println(threadName+"tag a,calculate over!");
}
if ("b".equals(tag)) {
num=num+100;
System.out.println(threadName+"," + tag +","+ "calculate over!");
}
System.out.println(threadName+","+tag+","+"num="+num);
}
- 打印结果为
thread1,tag a,calculate over!
thread1,a,num=100
等待5秒,确保thread1打印完毕
thread2,b,calculate over!
thread2,b,num=0
观察到主方法里面有2个对象:multiThread1与 multiThread2,
如果多个对象使用同一把锁,则上述执行的结果是:
thread2,b,num=-100.
所以得出结论:每一个对象都拥有一把的锁.
关键字Synchronized取得的锁都是对象锁,而不是把一段代码或者方法当做锁,
所以上述实例代码哪个线程先执行synchronized关键字的方法,哪个线程就持有该方法所属对象的锁.
现在有两个对象,线程获得的是两个不同的对象的锁,他们是互不影响的.
-
但是有一种情况:
所有的对象会对一个变量count进行操作? -
这时候我们可以用到static
用static修改的方法或者变量,在该类的所有对象是具有相同的引用的,
这样的话,无论实例化多少对象,调用的都是一个方案:
即把private int num=200;变成private static int num=200;
结果如下:
thread1,tag a,calculate over!
thread1,a,num=100
等待5秒,确保thread1打印完毕
thread2,b,calculate over!
thread2,b,num=-100
八.对象锁的同步和异步
- 同步(synchronized)
同步的概念就是共享,
如果不是共享的资源,就没必要进行同步,也就是没必要加锁
同步的目的就是为了线程安全,
对于线程的安全就要满足两个最基本的特性:原子性和可见性
-
异步(asynchronized)
异步的概念就是独立,相互之间不受到任何制约,两者之间没有任何关系.这里的异步可以理解为多个线程之间不会竞争共享资源. -
异步调用的实例:
package cn.itcast.mutilThread;
public class MyObject {
public void method(){
System.out.println(Thread.currentThread().getName());
//这就是异步的方法,一方面,它不会出现对共享变量的修改,
//另一方面,无需保证访问该方法的线程安全性
}
public static void main(String[] args) {
final MyObject myObject = new MyObject();
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
myObject.method();
}
},"t1");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
myObject.method();
}
},"t2");
thread.start();
thread2.start();
}
}
