1. 线程的创建和启动
1.1 概述
-
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
-
Thread类的特性
-
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常
把run()方法的主体称为线程体 -
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
-
1.2 创建多线程的方式一：继承Tread类
继承Thread类方式（这个在官方文档Tread类中有说明）
-
首先要创建一个继承于Thread类的子类
-
重写Thread类的run()方法 :将此线程执行的操作声明在run方法中
-
创建Thread类的子类的对象
-
通过此对象调用start()方法：它会启动一个线程，然后自动调用run()方法；不可以已经调用过start方法的线程再调用start。一个thread子类对象只能执行一次start
例子
//这也就是在主线程中创建一个线程
//例子：遍历100以内的偶数
class Mythread extends Thread {
private static int share = 100; // 创建一个共享变量
@Override
public void run() {
for (int i = 0; i <10000; i++) {//这里的i要大一点，因为线程是轮转的，
//数字太小在第一次分给这个线程的时间片内就足以把程序执行完毕，就体现不出是多线程在执行
if (i%2 == 0){
// 本来就是在这个线程之中声明的方法，这里面的方法默认就是调用this
// 所以Thread.currentThread() 可以省略
System.out.println(Thread.currentThread().getName()+": " +i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.start();
//mythread.run(); 如果这样的话它不会创建线程，也就是run里面的代码就是在主线程中跑的
System.out.println("asdsad");
for (int i = 0; i <10000; i++) {
if (i%2 == 0){
System.out.println(Thread.currentThread().getName()+": " +i);
}
}
}
}
当我们写多了之后就可以这样的写：
public class ThreadTest {
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0; i <10000 ; i++) {
System.out.println(Thread.currentThread().getName());
}
}
}.start();
}
1.3 Thread类常用方法
-
start() :启动当前线程，调用当前线程的run()
-
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
-
currentThread(): 静态方法返回执行，当前代码的线程。
-
getName() : 获取当前线程的名字
-
setName(): 设置当前线程的名字
-
yield():释放当前线程的执行权 （但可能在下一个时刻又是这个线程抢到了cpu）
-
join(): 在线程A中调用线程B的join方法，这时线程A就会进入阻塞状态(就算CPU想给你分配资源也没有用)，知道线程B完全执行完后，A才会结束阻塞状态
-
stop()：强制执行线程生命期结束，已经被弃用了，不建议使用。
-
sleep(long millis): 让当前线程阻塞指定的毫秒数
-
isAlive()：判断当前线程是否还存活
例子：
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0; i <10000 ; i++) {
Thread.currentThread().setName("线程0");
System.out.println(Thread.currentThread().getName());
if (i%20 == 0){
Thread.yield();// 释放当时线程cpu的执行权
//yield(); 质量不保证的，从java14开始就可能不支持了
}
}
}
}.start();
System.out.println("asdsad");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i <10000 ; i++) {
if (i%2 == 0){
System.out.println(Thread.currentThread().getName()+": " +i);
}
}
}
1.4 线程优先级
java线程的优先级分十个档次，高优先级的线程，被执行的概率比低优先级的线程的概率要高，并不意味着只有当高优先级的线程执行完后，低优先级才执行
/**
* The minimum priority that a thread can have.
*/
public static final int MIN_PRIORITY = 1;
/**
* The default priority that is assigned to a thread.
*/
public static final int NORM_PRIORITY = 5;
/**
* The maximum priority that a thread can have.
*/
public static final int MAX_PRIORITY = 10;
-
getPriority(): 获取线程的优先级
-
setPriority(int p):设置线程的优先级
1.5 创建多线程的方式二：实现Runnalbe
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8L6hukPB-1603245836121)(/Users/luca/MarkText-img-Support/2020-07-17-11-34-20-image.png)]
步骤：
-
创建一个实现Runnalbe接口的类
-
实现Runnable中的抽象方法：run()
-
创建实现类的对象
-
将此对象传入Thread类的构造器中，创建Thread的对象
-
通过Thread类的对象调用start()方法
//1- 创建一个实现Runnalbe接口的类
class Mthread implements Runnable{
private int share =100; //创建一个线程共享变量
//2- 实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i <10000; i++) {
if (i%2 == 0){
System.out.println(Thread.currentThread().getName()+": " +"priority: " + Thread.currentThread().getPriority() +i);
}
}
}
}
public class ThreadRunnbaleTest {
public static void main(String[] args) {
//3- 创建实现类的对象
Mthread mthread = new Mthread();//我么这里只造了一个对象，所以share是被这两个线程共享的
//4- 将此对象传入Thread类的构造器中，创建Thread的对象
Thread thread = new Thread(mthread);
//5- 通过Thread类的对象调用start()方法
thread.start();
}
}
1.6 比较两种创建线程的方式
开发中优先选择实现Runnable的方式：
-
java是单继承的，如果这个类继承了Thread类就不可以在继承别的类，这就会使我们这个类受到限制。而java是可以实现多个接口的， 所以使用实现Runnable接口不会出现这个问题
-
它更适合用来处理多线程共享数据的情况
二者的联系：
-
其实Thread的类也是继承了Runnable接口，Thread类也重写了Runnable接口中的run()，所以我们可以写一个类来继承Thread类，然后重写run()，本质上也就是重写了Runnable中的run()方法，或是直接写一个类来实现Runnable
-
两种方法都要重写run，将线程要执行的逻辑声明在run()方法中。
1.7 线程的生命周期
2. 线程同步
线程同步主要解决的就是线程安全问题。
2.1 最初的方式——synchronized
2.1.1 同步方法块
synchronized(同步监视器){
//需要被同步的代码
}
-
操作共享数据的代码就是需要被同步的代码
-
同步监视器，俗称：锁。任意一个类的对象都可以充当锁。多个线程必须使用同一把锁。 最方便地，我么可以使用当前对象this，但要确保这个对象只new一次。
-
注意⚠️：不要用String常量，Integer，Long等基本的数据类型当同步监视器
-
注意⚠️： 加锁的对象一定要记得加一个final，我们不希望这个引用指向别的对象，synchronized其实就是看这个锁定的对象的Markword，一旦这个引用指向别的对象了，原来对象的Markword都找不到了，这肯定会出问题。
class MYthread implements Runnable {
private int share = 0; //创建一个线程共享变量
final Object obj = new Object();//多个线程共用一个obj，将它来充当锁
@Override
public void run() {
synchronized (obj) {//使用synchronized来保证线程安全
for (int i = 0; i < 1000000; i++) {
share += 1;
}
}
}
}
2.1.2 同步方法
-
如果操作共享数据的代码块完整的声明在一个方法中，我们不妨将此方法声明为同步的。
-
使用了synchronized 关键字修饰的方法就成为同步方法
-
synchronized方法中，如果是实现Runnable方法 默认使用this来充当同步监视器；如果是继承Thread类则是用当前类(myClass.class)来充当同步监视器
class MYthread1 implements Runnable {
private int share = 0;
@Override
public void run() {
show();
}
private synchronized void show() {
for (int i = 0; i < 1000000; i++) {
share += 1;
}
}
}
public static void main(String[] args) {
//3- 创建实现类的对象
com.luca.Mthread1 mthread = new com.luca.Mthread(); //我么这里只造了一个对象，所以share是被这两个线程共享的
//4- 将此对象传入Thread类的构造器中，创建Thread的对象
Thread thread = new Thread(mthread);
//5- 通过Thread类的对象调用start()方法
thread.start();
//再启动一个线程
Thread thread1 = new Thread(mthread);
thread1.start();
}
2.2 使单例模式变为线程安全的
//使单例模式变为线程安全的
class Bank{
private Bank(){}
private static Bank instance = null;
public static synchronized Bank getInstance(){//只要加一个synchronized 就变成了线程安全的
if (instance == null){// 在一开始 instance是null，但是可能多个线程同时进来。
//比如 我在这里睡眠10秒，在一开始 instance是null，线程一已经进入的if语句，但是还在睡觉，没有给instance赋值
//这时，线程二也可以进来，到时候就会new多个对象，所以这里是线程不安全的.
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new Bank();
}
return instance;
}
}
上面的例子效率就会比较低：就算如果instance已经不为空了，但是大家还是要执行线程安全的代码，这样的效率就比较低。
public static Bank getInstanceFaster(){
if (instance == null) {
if (instance == null) {
if (instance == null) {
instance = new Bank();
}
}
}
return instance;
}
3. 锁——解决线程安全的方式二
-
从JDK 5.0开始，Java提供了更强大的线程同步机制一 通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
-
java.utiLconcurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
-
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
例子
class mythread implements Runnable {
private int share = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + "priority: " + Thread.currentThread().getPriority() + i);
}
}
} finally {
lock.unlock();
}
}
}
4. Lock与synchronized的异同
-
同：都是用来解决线程安全的
-
异：synchronized在执行完相应的同步代码后会自动的释放同步监视器；Lock则需要手动启动Lock，使用完毕后要手动释放锁。Lock它放置的位置比较灵活
5. 线程之间的通信
5.1 wait()/notify()
-
wait(): wait会使调用该方法的线程进入阻塞状态，并且会使该线程释放同步监视器
-
notify(): 唤醒被wait()方法阻塞的线程。如果有多个wait() 阻塞的线程，则唤醒优先级高的，总之它只会唤醒一个线程。但是调用notify的线程不会释放锁的，所以如果唤醒的线程与调用notify的线程用的是同一把锁，其实这个这个被唤醒的线程还是需要等这该线程执行完才能去抢锁。除非在notify后马上调用wait，把这个锁让出来给被唤醒的线程。
-
notifyAll()： 唤醒全部被wait()方法阻塞的线程；
说明：
-
上述三个方法必须使用在synchronized中，Lock中有其他的方法。
-
这三个方法的调用者是同步监视器。
-
上述三个方法是定义在Object类中
5.2 面试题：sleep( ) 与 wait()的异同
-
同：都会使调用这两个方法的线程进入阻塞状态
-
异：
-
因为wait() 涉及到线程之间的通信，所以必须由同步监视器来调用，所以它 必须在synchronized的代码快中调用。而sleep()没有相关的限制
-
sleep() 定义在thread类中，因为wait()是由同步监视器调用，而任何一个类都可以作为同步监视器，所以wait()得定义在Object中
-
wait()方法在阻塞线程后会释放线程的锁，而sleep()不会
-
6. JDK5后新增的两种线程创建方法
6.1 实现Callable接口
6.1.1 Callable接口
与实现Runnable相比，Callable接口下定义的call() 的功能更加强大
-
相比run()方法，call()可以有返回值
-
call()方法可以抛出异常
-
Callable支持泛型
-
call()需要借助FutureTask类，来执行一些操作，比如获取返回结果
6.1.2 Future 接口
-
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
-
FutrueTask是Futrue接口的唯一的实现类
-
FutureTask 同时实现了Runnable, Future接口。它婚可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
