1.Java中的线程
应用程序以进程为单位运行,一个进程之内可以分为一到多个线程
tips:
windows下可以通过任务管理器查看进程
linux下可以通过ps -fe
查看进程
(进程、线程都可以并行执行)
操作系统中有一个组件叫做任务调度器,将cpu的时间片分给不同的程序使用。
单核cpu微观串行,宏观并行。
而多核cpu可以实现真正的并行。
好处:
1) 多进程,多线程可以让程序不被阻塞.
2) 充分利用多核cpu的优势,提高运行效率
1.1.java中的多线程
Thread 类
创建线程的方法1:
继承Thread类:
public class ThreadClient {
public static void main(String[] args) {
Print p1 = new Print();
Print p2 = new Print();
p1.start();
p2.start();
}
}
class Print extends Thread{
@Override
public void run(){
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果:
Thread-0:0
Thread-1:0
Thread-0:1
Thread-1:1
Thread-0:2
Thread-1:2
Thread-0:3
Thread-1:3
Thread-0:4
Thread-1:4
Thread-0:5
Thread-1:5
Thread-0:6
Thread-1:6
Thread-0:7
Thread-1:7
Thread-0:8
Thread-1:8
Thread-0:9
Thread-1:9
创建线程的方法2:
实现Runnable接口:
public class ThreadClient1 {
public static void main(String[] args) {
Runnable p1 = new Salesman("Jack");
Runnable p2 = new Salesman("Iris");
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p2);
t1.start();
t2.start();
}
}
class Salesman implements Runnable{
private int ticket=100;//每个线程都拥有100张票
private String name;
Salesman(String name){
this.name=name;
}
@Override
public void run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+name+","+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果:
10 is saled by Jack,Thread-0
10 is saled by Iris,Thread-1
9 is saled by Jack,Thread-0
9 is saled by Iris,Thread-1
8 is saled by Jack,Thread-0
8 is saled by Iris,Thread-1
7 is saled by Iris,Thread-1
7 is saled by Jack,Thread-0
6 is saled by Iris,Thread-1
6 is saled by Jack,Thread-0
5 is saled by Iris,Thread-1
5 is saled by Jack,Thread-0
4 is saled by Iris,Thread-1
4 is saled by Jack,Thread-0
3 is saled by Iris,Thread-1
3 is saled by Jack,Thread-0
2 is saled by Iris,Thread-1
2 is saled by Jack,Thread-0
1 is saled by Iris,Thread-1
1 is saled by Jack,Thread-0
创建线程的方法3:
实现Callable接口:
格式:
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
测试:
// 代表一个任务对象
// Callable代表线程中要执行的代码
FutureTask task = new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
System.out.println(Thread.currentThread().getName()+"开始执行");
Thread.sleep(2000);
return "ok";
}
});
// 创建和启动新线程
new Thread(task).start();
// 获取返回结果
System.out.println(task.get());
运行结果:
Thread-0开始执行
ok
1.2线程中的常见方法
Thread.sleep(long n); // 让当前线程休眠n毫秒
Thread.currentThread(); // 找到当前线程
Thread.start(); //启动线程
Thread.join(); //等待某个线程执行结束
Thread.join(long n); //表示等待线程结束,但最多等待n毫秒
Thread.getName(); //得到线程的名称
Thread.yield(); //谦让
Thread.interrupt(); //打断正在等待的线程(包括sleep, join)
Thread.stop(); //让线程停止
Thread..suspend(); //让线程暂停
Thread..resume(); //让线程继续
注意:
1. main 方法实际是由主线程(main)来调用的
2. 可以使用jconsole 来查看某个java进程中线程的运行情况
3. start() 只能调用一次,如果调用多次会出现IllegalThreadStateException
4. 直接调用run和使用start()间接调用run的区别:
1)直接调用run()是在主线程中执行了run(),没有启动新的线程
2)使用start()调用run()启动了新的线程,通过新的线程调用run()
join() 例:
static int r = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1= new Thread(()->{
System.out.println("t1运行开始");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1运行结束");
r = 100;
});
t1.start();
/*System.out.println("main开始");
t1.join();
System.out.println("main结束");*/
t1.join();
System.out.println(r);
}
interrupt() 例:
Thread t = new Thread(()->{
try {
Thread.sleep(5000); // 被打断线程会抛出InterruptedException
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("结束 。。。");
});
t.start();
Thread.sleep(1000);
System.out.println("打断t线程。。。");
t.interrupt();
1.2.1守护线程
默认情况下,java进程需要等待所有线程都运行结束,才会结束。有一种特殊的线程叫做守护线程(守护的是主线程),只要主线程运行结束,即使守护线程的代码没有执行完,也会跟着主线程一起结束。
例:
Thread t1= new Thread(()->{
System.out.println("守护线程开始执行...");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("守护线程结束");
});
t1.setDaemon(true); // 设置该线程为守护线程
t1.start();
Thread.sleep(1000);
1.3线程的并发
1.3.1synchronized (同步关键字)
每个对象都有一个自己的monitor(监视器),当一个线程调用synchronized(对象),就相当于进入了这个对象的监视器。要检查有没有owner,如果没有,此线程成为owner; 但如果已经有owner了,这个线程在entryset的区域等待owner的位置空出来。
成为owner可以理解为获得了对象的锁
在竞争的时候,是非公平的
synchronized必须是进入同一个对象的monitor 才有上述的效果
格式:
synchronized(对象) {
要作为原子操作代码
}
用synchronized 解决并发问题:
static int i = 0;
static Object obj = new Object(); // 房间,能容纳一个人
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> { // 甲
for (int j = 0; j < 5000; j++) {
synchronized (obj) { // 甲会锁住这个房间
i++;
} // 甲从房间出来解开了锁
}
});
Thread t2 = new Thread(() -> { // 乙
for (int j = 0; j < 5000; j++) {
synchronized (obj) { // 乙 在门外等待
i--;
} //
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
synchronized的另外两种写法:
synchronized 语句块既可以保证代码块的原子性,也可以保证代码块内变量的可见性。
但缺点是synchronized是属于重量级操作,性能会受到影响。
一:
public synchronized void test() {
}
//等价于
public void test() {
synchronized(this) {
}
}
二:
class Test{
public synchronized static void test() {
}
}
//等价于
public static void test() {
synchronized(Test.class) {
}
}
1.3.2CAS机制(compare And swap 比较并交换):
synchronized可以称之为悲观锁,而CAS体现的是乐观锁。
原理:
(不会给共享资源加锁,而是做一个尝试)
先拿到旧值,查看旧值是否跟共享区域的值相等
如果不等,那么说明别的线程改动了共享区域的值,我的修改失败
如果修改失败,则重新尝试(自旋)
如果相等,那么我的修改成功
自增案例(i++):
int var5;
// 修改失败,没关系,重新尝试
do {
// 获取共享区域的最新值
var5 = this.getIntVolatile(var1, var2); // 10
// 比较并交换 最新值, 最新值+1
} while(! this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
1.3.3重入锁(ReentrantLock)
方法:
.lock() 加锁
.unlock() 解锁
例:
static int i = 0;
public static void main(String[] args) throws InterruptedException {
ReentrantLock rl = new ReentrantLock();
Thread t1 = new Thread(() -> {
for (int j = 0; j < 5000; j++) {
try {
rl.lock(); // 加锁
i++;
} finally {
rl.unlock(); // 保证解锁一定被执行
}
}
});
Thread t2 = new Thread(() -> {
for (int j = 0; j < 5000; j++) {
try {
rl.lock(); // 加锁
i--;
} finally {
rl.unlock(); // 保证解锁一定被执行
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
运行结果:
0
与synchronized的区别:
ReentrantLock 在高并发下性能较高,内存占用也较大。
1.4 volatile(易变的)
可以用来修饰成员变量和静态成员变量,可以防止线程从自己的高速缓存中查找变量的值,必须到主存中获取它的值。
tips:它保证的是变量在多个线程之间的可见性, 但不能保证原子性。
static boolean run = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(run){
// ....
}
});
t.start();
Thread.sleep(1000);
run = false;
}
//一个线程对run变量的修改对于另一个线程不可见,导致了另一个线程无法停止
1.5线程死锁
a线程获得了A对象的锁
接下来需要获取B对象的锁
b线程获得了B对象的锁
接下来需要获取A对象的锁
Object A = new Object();
Object B = new Object();
Thread a = new Thread(()->{
synchronized (A) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (B) {
System.out.println("操作...");
}
}
});
Thread b = new Thread(()->{
synchronized (B) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (A) {
System.out.println("操作...");
}
}
});
a.start();
b.start();
tips:检测死锁可以使用 jconsole工具
1.6wait() notify() notifyAll()
都属于Object对象的方法,它们都是线程之间进行协作的手段
obj.wait(); 让object监视器的线程等待
obj.notify(); 让object上正在等待的线程中挑一个唤醒
obj.notifyAll(); 让object上正在等待的线程全部唤醒
必须获得此对象的锁,才能调用这几个方法
例:
Object obj = new Object();
new Thread(()-> {
synchronized (obj) {
System.out.println("thread-0线程执行....");
try {
obj.wait(); // 让线程在obj上一直等待下去
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread-0其它代码....");
}
}).start();
new Thread(()-> {
synchronized (obj) {
System.out.println("thread-1线程执行....");
try {
obj.wait(); // 让线程在obj上一直等待下去
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread-1其它代码....");
}
}).start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("唤醒obj上其它线程");
synchronized (obj){
// obj.notify();
obj.notifyAll();
}
}
1.7CountDownLatch(倒计时)
使用场景:当希望多个线程执行完毕后,再进行下一步操作时。
例:
public static void main(String[] args) throws InterruptedException {
CountDownLatch cdl = new CountDownLatch(3);// 构造方法需要指定倒计时的数字
new Thread(()->{
System.out.println("线程1开始运行"+new Date());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1准备完成"+new Date());
cdl.countDown();
}).start();
new Thread(()->{
System.out.println("线程2开始运行"+new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程2准备完成"+new Date());
cdl.countDown();
}).start();
new Thread(()->{
System.out.println("线程3开始运行"+new Date());
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程3准备完成"+new Date());
cdl.countDown();
}).start();
// 主线程等待,直到倒计时为0
System.out.println("主线程等待");
cdl.await();
System.out.println("ready go....");
}
运行结果:
主线程等待
线程1开始运行Thu Aug 16 14:53:58 CST 2018
线程2开始运行Thu Aug 16 14:53:58 CST 2018
线程3开始运行Thu Aug 16 14:53:58 CST 2018
线程2准备完成Thu Aug 16 14:53:59 CST 2018
线程3准备完成Thu Aug 16 14:54:00 CST 2018
线程1准备完成Thu Aug 16 14:54:00 CST 2018
ready go....
模拟十个玩家加载进度例子:
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(10);
String[] all = new String[10];
for (int j = 0; j < 10; j++) {
int x = j;
new Thread(()->{
Random r = new Random();
for (int i = 0; i <= 100; i++) {
try {
Thread.sleep(r.nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (all){
all[x]=(i+"%");
System.out.print("\r"+Arrays.toString(all));
}
}
latch.countDown();
}).start();
}
latch.await();
System.out.println("\nend...");
}
运行结果:
[100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%]
end...
1.8CyclicBarrier(循环栅栏)
使用场景:当满足CyclicBarrier设置的线程个数时,则继续执行,不满足则等待
例:
CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
new Thread(()->{
System.out.println("线程1开始.."+new Date());
try {
cb.await(); // 当个数不足时,等待
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("线程1继续向下运行..."+new Date());
}).start();
new Thread(()->{
System.out.println("线程2开始.."+new Date());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
cb.await(); // 2 秒后,线程个数够2,继续运行
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("线程2继续向下运行..."+new Date());
}).start();
与CountDownLatch(倒计时)的区别:
CountDownLatch只能使用一次,结束后此对象就没用了,而CyclicBarrier可以重复利用。
1.9 信号量
使用场景:限制了能同时运行的线程上限
Semaphore s = new Semaphore(3); // 限制了能同时运行的线程上限
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
s.acquire(); // 获得此信号量
System.out.println("我是线程" + Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release(); // 释放信号量
}
}).start();
}
1.10线程的状态
五种状态:
NEW(新建), RUNNABLE(可运行) , RUNNING(正在运行), 阻塞(BLOCKED,WAITING, TIMED_WAITING )TERMINATED(终止)
NEW(新建) 线程刚被创建,但是还没有调用 start方法
RUNNABLE(可运行)
当调用了start() 方法之后
RUNNING(正在运行)
BLOCKED(阻塞)
当线程进入了monitor监视器区,处于entrySet里准备竞争锁的时候,处于阻塞状态
WAITING(等待)
当调用了对象的wait方法,或调用了线程对象的join方法,进入了WaitSet,处于等待状态
TIMED_WAITING(限时等待)
当调用wait(long n) join(long n) 进入了WaitSet,处于有限时的等待状态
当调用sleep(long n) 是让当前线程放弃cpu的时间片,睡眠一会
TERMINATED(终止)当线程代码运行结束