wordpress怎么自动更新网站地图友情链接交换方式有哪些

1. 进程是包含线程的. 每个进程⾄少有⼀个线程存在，即主线程。
2.  进程和进程之间不共享内存空间. 同⼀个进程的线程之间共享同⼀个内存空间。
3. 进程是系统分配资源的最⼩单位，线程是系统调度的最⼩单位。
4. ⼀个进程挂了⼀般不会影响到其他进程. 但是⼀个线程挂了, 可能把同进程内的其他线程⼀起带⾛(整个进程崩溃).

4) Java 的线程 和 操作系统线程 的关系 

 1.2 第⼀个多线程程序

• 每个线程都是⼀个独⽴的执⾏流

• 多个线程之间是 "并发" 执⾏的.

可以使用jconsole观察线程的状态，具体怎么使用后面学习.

 1.3 创建线程

class MyThread extends Thread {@Overridepublic void run() {System.out.println("这⾥是线程运⾏的代码");}
}

MyThread t = new MyThread();

t.start(); // 线程开始运⾏

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("这⾥是线程运⾏的代码");}
}

 方法3：匿名内部类，创建Thread子类

方法4：匿名内部类，创建Runnable子类

 方法5：lambda表达式

2. Thread 类及常⻅⽅法

 2.1 Thread 的常⻅构造⽅法

演示：

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

 2.1 Thread 的⼏个常⻅属性（重点）

解释：

ID 是线程的唯⼀标识，不同线程不会重复

名称是各种调试⼯具⽤到

状态表⽰线程当前所处的⼀个情况，下⾯我们会进⼀步说明

优先级⾼的线程理论上来说更容易被调度到（抢占资源）

关于后台线程，需要记住⼀点： JVM会在⼀个进程的所有⾮后台线程结束后，才会结束运⾏。

是否存活，即简单的理解，为 run ⽅法是否运⾏结束了

线程的中断问题，等等我们会解释到。

是否为后台线程：

一次都没有打印就结束，因为main线程结束的很快。mian是前台线程，thread是后台线程。也可以判断线程是否为后台线程。

是否存活：

2.2线程的中断（重点）

 ⽬前常⻅的有以下两种⽅式：

1. 通过共享的标记来进⾏沟通

2. 调⽤ interrupt() ⽅法来通知

标志位 中断（终止）

 调用intterrupt()

 解释

 但是这里有一个问题：

会一直陷入死循环，为什么，

解释：

解决方法：

加上break

2.3等待⼀个线程 - join()

比如说：现在有两线程a,b,在a线程中调用b.join()

就是a线程等待b线程先结束，a线程在执行。

join的作用：就是能让先结束的线程先结束

 2.4 获取当前线程引⽤

这个方法我们已经很熟悉了,用来获取当前线程的引用。

 2.5休眠当前线程（sleep）

3. 线程的状态

打印线程状态:线程变量名.getState();

这个我就不多演示，后面我会给大家带来jcomsole工具，java自带工具的使用。 

 4. 多线程带来的的⻛险-线程安全 (重点)

4.1 观察线程不安全 

比如说：现在让两个

代码：

public class Demo9 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {// 对 count 变量增5w次for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {// 对 count 变量增5w次for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();// 预期结果应该是 10wSystem.out.println("count: " + count);}
}

结果：

原因：

4.2 线程安全的概念 

4.3 线程不安全的原因

线程调度是随机的

随机调度使⼀个程序在多线程环境下, 执⾏顺序存在很多的变数.

程序猿必须保证 在任意执⾏顺序下 , 代码都能正常⼯作

原⼦性

什么是原⼦性

我们把⼀段代码想象成⼀个房间，每个线程就是要进⼊这个房间的⼈。如果没有任何机制保证，A进⼊房间之后，还没有出来；B 是不是也可以进⼊房间，打断 A 在房间⾥的隐私。这个就是不具备原⼦性的。

是不是只要给房间加⼀把锁，A 进去就把⻔锁上，其他⼈是不是就进不来了。这样就保证了这段代码的原⼦性了。 有时也把这个现象叫做同步互斥，表⽰操作是互相排斥的。

⼀条 java 语句不⼀定是原⼦的，也不⼀定只是⼀条指令

⽐如刚才我们看到的 count++，其实是由三步操作组成的：

1. 从内存把数据读到 CPU

2. 进⾏数据更新

3. 把数据写回到 CPU

可⻅性

可⻅性指, ⼀个线程对共享变量值的修改，能够及时地被其他线程看到.

Java 内存模型 (JMM): Java虚拟机规范中定义了Java内存模型.

⽬的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到⼀致的 并发效果.

• 线程之间的共享变量存在 主内存 (Main Memory).
• 每⼀个线程都有⾃⼰的 "⼯作内存" (Working Memory) .
• 当线程要读取⼀个共享变量的时候, 会先把变量从主内存拷⻉到⼯作内存, 再从⼯作内存读取数据.

• 当线程要修改⼀个共享变量的时候, 也会先修改⼯作内存中的副本, 再同步回主内存.

由于每个线程有⾃⼰的⼯作内存, 这些⼯作内存中的内容相当于同⼀个共享变量的 "副本". 此时修改线程1 的⼯作内存中的值, 线程2 的⼯作内存不⼀定会及时变化.

演示过程：

 1) 初始情况下, 两个线程的⼯作内存内容⼀致.

2) 为啥要这么⿇烦的拷来拷去? 

4.4 解决之前的线程不安全问题

代码：

public class Demo9 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次for (int i = 0; i < 50000; i++) {synchronized (locker) {count++;}}});Thread t2 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次for (int i = 0; i < 50000; i++) {synchronized (locker) {count++;}}});t1.start();t2.start();t1.join();t2.join();// 预期结果应该是 10wSystem.out.println("count: " + count);}
}

结果：

5. synchronized 关键字 - 监视器锁 monitor lock

5.1 synchronized 的特性

1) 互斥

进⼊ synchronized 修饰的代码块, 相当于 加锁

退出 synchronized 修饰的代码块, 相当于 解锁

synchronized⽤的锁是存在Java对象头⾥的。  

 2) 可重⼊

理解 "把⾃⼰锁死" 

⼀个线程没有释放锁, 然后⼜尝试再次加锁.

// 第⼀次加锁, 加锁成功

lock();

// 第⼆次加锁, 锁已经被占⽤, 阻塞等待.

lock();

按照之前对于锁的设定, 第⼆次加锁的时候, 就会阻塞等待. 直到第⼀次的锁被释放, 才能获取到第⼆个锁. 但是释放第⼀个锁也是由该线程来完成, 结果这个线程已经躺平了, 啥都不想⼲了, 也就⽆法进 ⾏解锁操作. 这时候就会 死锁。

这样的锁称为 不可重⼊锁.

 Java 中的 synchronized 是 可重⼊锁,像c++和python是不可重入锁。

5.2 synchronized 使⽤⽰例  

1) 修饰代码块: 明确指定锁哪个对象.

public class SynchronizedDemo {private Object locker = new Object();public void method() {synchronized (locker) {}}
}

public class SynchronizedDemo {public void method() {synchronized (this) {}} 
}

public class SynchronizedDemo {public synchronized void methond() {}
}

public class SynchronizedDemo {public synchronized static void method() {}
}

5.3 Java 标准库中的线程安全类 

•

LinkedList

•

HashMap

•

TreeMap

•

HashSet

•

TreeSet

•

StringBuilder

但是还有⼀些是线程安全的. 使⽤了⼀些锁机制来控制。

Vector (不推荐使⽤)

•

HashTable (不推荐使⽤)

•

ConcurrentHashMap

•

StringBuffer

StringBuffer 的核⼼⽅法都带有 synchronized。

还有的虽然没有加锁, 但是不涉及 "修改", 仍然是线程安全的

String

6. volatile 关键字

volatile 能保证内存可⻅性。

volatile 修饰的变量, 能够保证 "内存可⻅性".

按照翻译：

来我们写一个代码，只要输入0就会停止线程。

代码：

public class Demo10 {static volatile int n = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {while(true) {//啥都不写}});Thread t2 = new Thread(() -> {Scanner sc = new Scanner(System.in);System.out.println("请输入一个整数：");n = sc.nextInt();});}
}

结果：

结果捏

这就是可见性问题。

原因：

 volatile 不保证原⼦性

public class Demo9 {private volatile static  int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();// 预期结果应该是 10wSystem.out.println("count: " + count);}
}

好了今天就讲到这里。