多线程聚合
写这篇的目的是回顾多线程，纯属个人总结，不足之处，大家多多指导
引言
- 在我看来，随着商业化网络的大肆发展，许多许多的商业网站，类似淘宝，京东，这种大规模的进行网上交易，牵扯到的一些问题，类似高并发这种问题。虽然在当代，许多许多的框架为我们封装了一系列的操作，让我们对这种高并发问题的产生得到了有效的处理，但是作为程序员我们必须要了解一些底层性，最基础的概念，多线程反而到成了我们学习的不二之选
- 在多核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]);
}
}
}
执行结果一样
后面 会讲到 一些 底层 出现死锁 怎么解决 一些线程池的使用 还有 一些安全且高效的集合 未完待续 还会适当复习一些集合 欢迎一起学习
1651
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
