多线程聚合
写这篇的目的是回顾多线程,纯属个人总结,不足之处,大家多多指导
引言
- 在我看来,随着商业化网络的大肆发展,许多许多的商业网站,类似淘宝,京东,这种大规模的进行网上交易,牵扯到的一些问题,类似高并发这种问题。虽然在当代,许多许多的框架为我们封装了一系列的操作,让我们对这种高并发问题的产生得到了有效的处理,但是作为程序员我们必须要了解一些底层性,最基础的概念,多线程反而到成了我们学习的不二之选
- 在多核cpu或者单核下,每一个应用广义的去讲就是一个进程,多个应用之间并发执行,意味着多个进程并发执行,在进程中有线程的概念,多个线程微观呈一种串行化方式去执行。
java中的线程
- 首先要明确java中没有多进程程的概念,因为jvm虚拟机是一个进程,进程中只有多线程,其中线程是串行话的去执行
- 线程的组成:
- cpu时间片
- 运行数据
- 代码
- java中到目前为止只有多线程的概念没有多进程,main 是java中的主线程
关于线程中一些概念
线程主要分为这么几个阶段
一开始是初始状态,调用start() 进入就绪状态 ,然后谁先获得cpu时间片谁就进入运行状态,cpu时间片到期又会进行就绪状态,其中到达运行状态会可以掉用sleep()方法 让当前线程休眠,此时cpu时间片释放,这是有限期等待状态,如果在当前线程掉用join()方法 ,当前线程让步于被调用的线程,当被调用的线程执行完毕,才会进入当前线程,此称之为无限期等待状态,每一个java对象都存在这一把互斥锁,保证了其临界资源不受破坏,也为了原子操作的顺序,而最终保护数据得正确性,引入了锁的概念,synchronized 也叫互斥锁,意思是只有拿到当前对象的锁标记,才能对当前对象进行操作,如果没有拿到锁标记在cpu时间片释放的时候,在其他线程操作当前对象的时候会进入阻塞状态,而在就绪状态中等待,只有当所有线程都执行完毕,才会进入终止状态 还有一个方法 是Thread 中的静态方法 yield 意味是 放弃 cpu 回到 就绪状态 但是这种保证不了cpu再次会回到当前线程上
在java中堆空间,所有线程共享
原子操作
: 为了保证临界资源的正确性,数据的一致性,其执行的顺序,不能被打破,要不失败,要不成功
临界资源
:被多个线程共享的一个对象
互斥锁
: 保证每个对象有且只有一把锁,当当前线程没有释放锁标记的同时,其他线程无法对该对象进行操作,尽管已经拿到cpu时间片
守护线程
: 调用Thread 类中有一个方法 setDaemon(true) 谁调用我这个方法谁就是守护线程/精灵线程,当其他线程执行完毕,我这个线程不管有没有执行完毕 ,都会进入终止状态
死锁
: 在通过synchronized 进行加锁的 时候 该方法可以嵌套定义,也就是说我该对象的锁标记没有释放 在另一个线程中又要使用,我该对象的第一层锁标记已经释放,在第二层锁标记,我拿不到 另一个线程中的第一个锁标记,导致我永远无法释放双锁 ,也导致 第二个线程永远也无法执行,会造成死锁问题
线程的创建
- 继承Thread 并且重写里面的run方法 ,通过start() 来启动
package threaddemo;
public class TestThread {
public static void main(String[] args) {
Thread1 th = new Thread1();
th.start();
}
}
class Thread1 extends Thread{
public void run(){
System.out.println("Thread is Running");
}
}
注意: 通过直接调用run 方法 是普通的方法调用 不是开启线程
- 实现Runnable 接口 并实现里面的run方法
package threaddemo;
public class TestRunnable {
public static void main(String[] args) {
Thread th = new Thread(new Thread2());
th.start();
}
}
class Thread2 implements Runnable {
@Override
public void run() {
System.out.println("runnable is running");
}
}
-
实现callable 接口 并实现里面的call 方法 ,通过 线程池的submit 来获取结果Future获取结果,通过get 去拿到返回值
此方法 会实现一个call方法 带有泛型为返回值,并同时抛出异常 关于线程池 底下会另做说明
package threaddemo;
import java.util.concurrent.*;
public class TestCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService es = Executors.newCachedThreadPool();
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
String message = "callable is running";
return message;
}
};
Future<String> submit = es.submit(callable);
System.out.println(submit.get());
}
}
没有锁带来的问题
package threaddemo;
public class TestSynchronized {
public static void main(String[] args) throws Exception{
Arrays ary = new Arrays();
Thread th1 = new Thread(new Runnable() {
@Override
public void run() {
ary.add("C");
}
});
Thread th2 = new Thread(new Runnable() {
@Override
public void run() {
ary.add("D");
}
});
th1.start();
th2.start();
th1.join();
th2.join();
ary.each();
}
}
class Arrays {
private String[] strs = {"A", "B", "", "", ""};
private int index = 2;
public void add(String str) {
strs[index] = str;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
index++;
}
public void each() {
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
结论: 在当前代码中可以看出来, 在时间片刚刚到达add方法进行++ 的时候 时间片会离开到达线程二 其中会add 覆盖之前的字母,才会导致结果出现 ABC 或者 ABD
怎么解决 ? 上锁 ,用互斥锁 来保证其临界资源的正确性,其原子操作不会受到破坏 给当前临界资源加锁
同步方法和同步代码快的简单使用
1.同步代码快
/*
语法
synchronized(o){ o 代表临界资源
代码快
}
*/
package threaddemo;
public class TestSynchronized {
public static void main(String[] args) throws Exception{
Arrays ary = new Arrays();
Thread th1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (ary){
ary.add("C");
}
}
});
Thread th2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (ary){
ary.add("D");
}
}
});
th1.start();
th2.start();
th1.join();
th2.join();
ary.add("E");
ary.each();
}
}
class Arrays {
private String[] strs = {"A", "B", "", "", ""};
private int index = 2;
public void add(String str) {
strs[index] = str;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
index++;
}
public void each() {
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
打印输出 A B C D E
2. 同步方法
/*
语法
synchronized 可以做为修饰符来使用
*/
package threaddemo;
public class TestSynchronized {
public static void main(String[] args) throws Exception{
Arrays ary = new Arrays();
Thread th1 = new Thread(new Runnable() {
@Override
public void run() {
ary.add("C");
}
});
Thread th2 = new Thread(new Runnable() {
@Override
public void run() {
ary.add("D");
}
});
th1.start();
th2.start();
th1.join();
th2.join();
ary.add("E");
ary.each();
}
}
class Arrays {
private String[] strs = {"A", "B", "", "", ""};
private int index = 2;
public synchronized void add(String str) {
strs[index] = str;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
index++;
}
public void each() {
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
执行结果一样
后面 会讲到 一些 底层 出现死锁 怎么解决 一些线程池的使用 还有 一些安全且高效的集合 未完待续 还会适当复习一些集合 欢迎一起学习