多线程
进程是指在系统中正在运行的一个应用程序。
线程是一个进程中的执行场景/执行单元，是系统分配处理器时间资源的基本单元。
一个进程可以启动多个线程
Java进程
在运行java程序时，会先启动jvm，jvm就是一个进程，之后jvm再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾。因此java程序中至少有两个线程并发
进程与线程的关系
进程可以看做显示生活中当中的公司
京城可以看作是公司当中的某个员工
注意java中：
- 进程之间内存独立不共享
- 线程之间，堆内存和方法区内存共享，但是栈内存独立，一个进程一个栈
java之所以有多线程机制，目的是为了提高程序的处理效率。
jvm内存图：
在java中实现多线程
第一种方法：编写一个类，直接继承Tread类，重写run方法
public class PropertiesTest {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行
//新建一个分支线程的对象
MyThread myThread = new MyThread();
/*启动线程
start（）方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，瞬间就执行完了。
这段代码的任务是开辟一个新的站控见，只要新的栈空间开出来，start方法就结束了，线程就启动成功了。
启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是评级的
*/
myThread.start();
//这里的代码还是运行在主线程中的
for(int i = 0; i<1000;i++){
System.out.println("主线程--->"+i);
}
}
}
class MyThread extends Thread{
public void run(){
for(int i = 0; i < 1000; i++){
System.out.println("支线程---->>"+i);
}
}
}注意：如果直接在main方法里执行run方法，并不会开辟新的线程，此时run方法是压入主栈中的。
注意：run方法不能throws 异常，因为其父类没有抛出异常，子类不能比父类抛出更多的异常
第二种方法：编写一个类，实现Runnable接口，实现run（）方法
public class PropertiesTest {
public static void main(String[] args) {
//创建一个可运行的对象
MyRunnable r = new MyRunnable();
//将可运行的对象封装成一个线程对象
Thread t = new Thread(r);
t.start();
for(int i = 0; i < 1000; i++){
System.out.println("主线程---->>"+i);
}
}
}
class MyRunnable implements Runnable{
public void run(){
for(int i = 0; i < 1000; i++){
System.out.println("支线程---->>"+i);
}
}
}第三种方法（JDK8新特性）：
这种方式实现的线程可以获取线程的返回值（之前的两种方法由于是void类型，所以没有返回值）。例如，系统委派一个线程去执行一个任务，这个线程执行结束后会有一个执行结果，可以使用第三种方式实现Callable接口，来创建线程，这样创建出来的线程可以有返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) throws Exception{
//创建一个未来任务对象
FutureTask task = new FutureTask(new Callable<Integer>() {
//call方法就相当于run方法,但是可以有返回值
public Integer call(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int a = 100;
int b = 200;
return a+b;
}
});
//创建线程
Thread t = new Thread(task);
//启动线程
t.start();
//获取线程执行结果，如果线程没有结束，会将当前线程阻塞。
Object result = task.get();
System.out.println(result);
}
}这种方式的优点：可以获取到线程的执行结果
缺点：效率较低，在获取t线程执行结果的时候，当前线程会被阻塞。
线程的生命周期
常用方法
获取线程对象的名字
String getName();
举个例子：获取线程的默认名字
public class PropertiesTest {
public static void main(String[] args) {
//创建一个可运行的对象
MyRunnable r = new MyRunnable();
//将可运行的对象封装成一个线程对象
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
System.out.println(t1.getName());
System.out.println(t2.getName());
t1.start();
t2.start();
}
}
class MyRunnable implements Runnable{
public void run(){
for(int i = 0; i < 1000; i++){
System.out.println("支线程---->>"+i);
}
}
}输出线程的名字为
Thread-0
Thread-1
由此可见线程默认的名字是Thread-x x为第几个创建的线程。
修改线程对象的名字
void setName(String name);
获取当前线程,返回值即当前线程
Thread Thread.currentThread();
休眠当前线程
static void sleep(long 毫秒)
在哪个线程里调用sleep，哪个线程就休眠，进入阻塞状态。
终断线程的睡眠
void interrput()；
依靠java的异常处理机制来实现，调用interrput之后，sleep会报异常，直接引发线程结束
强行终止一个线程
stop()
已经过时，不推荐使用，过时原因是：线程被强行关闭时，可能会发生数据丢失
合理终止一个线程
给要实现多线程的类添加一个变量，这个变量来标识当前线程是否已经结束
public class PropertiesTest {
public static void main(String[] args) {
//创建一个可运行的对象
MyRunnable r = new MyRunnable();
MyRunnable r1 = new MyRunnable();
//将可运行的对象封装成一个线程对象
Thread t1 = new Thread(r);
t1.start();
for(int i = 0 ;i <1000;i++){
System.out.println("主线程"+i);
}
r.run = false; //结束线程
}
}
class MyRunnable extends Thread{
boolean run = true;
public void run(){
for(int i = 0; i < 1000; i++){
if(run){
System.out.println(getName()+"---->>"+i);
}else{
return ;
}
}
}
}设置线程的优先级和获取线程的优先级
void setPriority();
int getPriority();
最低优先级为1，默认优先级为5，最高优先级为10
暂停当前线程，让位给其他线程
static void yield();
该方法只会让线程进入就绪状态。
合并线程
void join(); //等待当前这个线程死亡，其实也就算是当前线程并入到主线程里了
例如
public class Test { public static void main(String[] args) { MyThread t = new MyThread(); t.start(); try { t.join(); //等待当前线程结束 } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0;i < 1000; i++){ System.out.println("主线程----》》"+i); } } } class MyThread extends Thread{ public void run(){ for( int i = 0;i < 1000; i++){ System.out.println("支线程-----》》"+i); } } }输出结果为
支线程--->>0
……
支线程---->>999
主线程---->>0
……
如何解决线程安全问题
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，那么就存在线程安全问题
例如 银行取钱问题，有一个银行账户余额为10000，小A和小B对该银行账户各取钱5000，那么A取钱，这时候B也取钱，两个取钱相当于两个线程，那么每个线程执行取钱方法后还要执行更新银行账户余额的操作，那么就存在一个时机，即A取出钱，但程序还没来得及更新余额为5000，B又取钱（此时余额还是10000），然后B所在线程也要执行程序使余额变为5000。最后，银行余额变为了5000。
解决线程安全必须在涉及到共享变量时让 线程排队执行(不能并发)，这种机制叫线程同步机制
这里涉及到两个概念
异步编程模型：线程t1和线程t2，各执行各的，互不影响，这种模型叫做：异步编程模型
其实也就是多线程并发
同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待t2线程的结束，或者在线程t2执行的时候，必须等待t1线程的结束.两个进程之间发生了等待关系，这就是同步编程模型
在java中可以使用synchronized来实现线程同步，基本语法如下
synchronized代码块
synchronized(谁的共享对象){
//线程同步代码块
}
()中写什么？
让哪几个线程同步就写哪几个线程的共享变量，例如：
有t1 t2 t3 t4 t5 五个线程
你希望t1 t2 t3线程同步， t4 t5 需要排队。
那么只需要在()中写一个t1 t2 t3 共享的对象而对t4 t5来说是不共享的即可synchronized修饰实例方法
[修饰符] synchronized 返回类型 实例方法名(){
}修饰实例方法的话，共享对象一定是this，所以这种方法不灵活，并且由于同步的是一个方法，可能会无故扩大同步范围，所以效率较低
synchronized修饰静态方法
[修饰符] synchronized static 返回类型 实例方法名(){
}表示找类锁，类锁永远只有一把，用来保证静态变量的线程安全
实现银行账户取钱线程同步：
银行账户类
public class Account {
private String no;
private double Balance;
public Account(String no, double balance) { this.no = no;Balance = balance; }
public Account() { }
public String getNo() { return no; }
public void setNo(String no) { this.no = no; }
public double getBalance() { return Balance; }
public void setBalance(double balance) { Balance = balance; }
//取钱
public void withdraw(double money){
synchronized(this) {
double beforeBalance = this.getBalance();
double afterBalance = beforeBalance - money;
try {
Thread.sleep(1000);//模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(afterBalance);
}
}
}
测试类以及银行账户线程类
public class Test {
public static void main(String[] args) {
Account account=new Account("act-01",10000.0);
//创建两个线程
AccountThread t1 = new AccountThread(account);
AccountThread t2 = new AccountThread(account);
//启动线程
t1.start();
t2.start();
}
}
class AccountThread extends Thread{
private Account account;
public AccountThread(Account account){
this.account = account;
}
public void run(){
account.withdraw(5000);
System.out.println("账户act-01取款5000成功，余额"+account.getBalance());
}
}这样输出结果就对了
以上同步代码块的执行原理：
- t1和t2线程并发，开始执行代码，肯定有一个先一个后
- 假设t1先执行了，遇到了synchronized，这个时候自动找()里共享对象的对象锁，找到并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占用这把锁的，当同步代码块执行结束，才会释放这把锁
- 假设t1已经占有了这把锁，此时t2也遇到了synchronized关键字，也会去尝试占用共享对象的对象锁，但是这把锁已经被t1占有了，t2只能在同步代码块歪等待t1的结束。当t1执行同步代码块结束并释放对象锁后，t2在占用对象锁再执行同步代码块
JAVA中三大变量
实例变量：存在堆中
静态变量：存在方法区
局部变量：存在栈中
以上三大变量中局部变量永远不会存在线程安全问题，因为局部变量在栈中，而栈并不会被多个线程共享。常量也不会有线程安全问题，因为常量不能被改变。
如果使用局部变量的话
建议使用：StringBuilder
因为局部变量不存在线程安全问题，选择StringBuffer（线程安全）效率较低
另外，ArrayList HashMap HashSet LinkedList是非线程安全的
HashTable Vector是线程安全的
死锁
首先看这样一个代码，MyThread1和MyThread2两种线程，共享o1 o2，但MyThread1是先请求o2 对象锁再请求o1对象锁，而MyThread2是先请求o1在请求o2。那么当两个线程开启后，可能存在一种情况：MyThread1占有了o2的对象锁，MyThread2占有了o1的对象锁，之后MyThread1永远也请求不到o1的对象锁，因为MyThread2永远请求不到o2，进而无法释放o1.这样就发生了死锁。
class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized(o2){
synchronized (o1){
}
}
}
}
class MyThread2 extends Thread{
Object o1;
Object o2;
public MyThread2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized(o1){
synchronized (o2){
}
}
}
}守护线程
java中线程分为两大类：
1.用户线程
例如main方法就是一个守护线程
2.守护线程
具有代表性的就是垃圾回收线程
特点是：一般守护线程是一个死循环，所有的用户线程结束，守护线程自动结束
如何将线程设置为守护线程
线程对象.setDaemon(true)；
当所有用户线程结束后，守护线程强制结束，
注意，必须在线程运行前设置为守护线程，否则会抛出异常
在守护线程中产生的新线程也是守护线程
定时器
间隔特定的时间，执行特定的程序
要实现这个功能，有以下几种方案：
- sleep方法（最原始的定时器）
- 使用java.until.Timer(不常用)
- String中提供的StringTask框架(使用较多，通过java.until.Timer实现)
实现定时器
| Constructor and Description |
|---|
Timer() 创建一个新的计时器。 |
Timer(boolean isDaemon) 创建一个新的定时器，其相关线程可以指定为 run as a daemon 。 |
Timer(String name) 创建一个新的定时器，其相关线程具有指定的名称。 |
Timer(String name, boolean isDaemon) 创建一个新的定时器，其相关线程具有指定的名称，可以指定为 run as a daemon 。 |
主要方法
| Modifier and Type | Method and Description |
|---|---|
void | cancel() 终止此计时器，丢弃任何当前计划的任务。 |
int | purge() 从该计时器的任务队列中删除所有取消的任务。 |
void | schedule(TimerTask task, Date time) 在指定的时间安排指定的任务执行。 |
void | schedule(TimerTask task, Date firstTime, long period) 从指定 的时间开始 ，对指定的任务执行重复的 固定延迟执行 。 |
void | schedule(TimerTask task, long delay) 在指定的延迟之后安排指定的任务执行。 |
void | schedule(TimerTask task, long delay, long period) 在指定 的延迟之后开始 ，重新执行 固定延迟执行的指定任务。 |
void | scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 从指定的时间 开始 ，对指定的任务执行重复的 固定速率执行 。 |
void | scheduleAtFixedRate(TimerTask task, long delay, long period) 在指定的延迟之后 开始 ，重新执行 固定速率的指定任务。 |
TimeTask是一个抽象类
实现一个日志定时器：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class Test {
public static void main(String[] args) throws Exception{
//创建定时器对象
Timer timer = new Timer();
//约定日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d = sdf.parse("2020-10-3 16:08:00");
//设定定时任务
timer.schedule(new TimeTask(),d,10*1000);
//第一个参数是TimerTask类型的引用，这个对象继承了Runnable接口，并且是一个抽象类
//因此需要自己建一个类来继承TimerTask并实现run方法
}
}
//假设这是一个记录日志的定时任务
class TimeTask extends TimerTask{
public void run(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date d= new Date();
String strTime = sdf.format(d);
System.out.println(strTime+"完成数据备份");
}
}
输出结果为：
建议将定时器设置为守护线程，否则将持续运行
关于Object类中的wait和notity方法
关于wait和notity不得不说的秘密
- wait和notity方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方法是Object类中自带的。
- wait()方法调用者应该是线程中的变量，如 Object o = new Object() o.wait() 表示让正在o对象上活动的线程进入等待状态，无限期等待，直到被唤醒为止，并且释放线程占用的o的锁
- notity()方法，o.notity()表示唤醒在o对象上等待的一个线程，只是通知，并不会释放线程之前占有的锁
- notityAll()方法，o.notity()表示唤醒在o对象上等待的所有线程
消费者和生产者模式
现实中存在这么一种情景，生产者负责生产产品，存入仓库，仓库满了就不生产了，消费者从仓库购买产品，仓库空了，就不购买了。这是一种特殊的业务需求，需要使用wait和notity方法才可以实现
首先应该明确，可以用多线程来实现，一个线程为生产者，另一个线程是消费者，由于存在一个关系：生产和消费一直在发生，所以每个线程必须一直在执行，不能执行结束，销毁线程。其次既然是多线程，而且这两个线程会修改其共享的仓库中产品的数量，因此必然需要使用线程同步机制。还存在一个问题，当仓库满了时候，生产者线程不能再生产了，当仓库空的时候，消费者线程不能购买了，所以当仓库满了，应让生产者线程休眠，然后执行消费者线程，但是这样就存在一个问题，仓库对象锁还被生产者线程占用，所以就有了wait方法的使用，在生产者线程中调用wait方法，让生产者线程休眠，释放仓库对象锁，消费者线程执行，生产产品，当仓库满了时，生产者线程再调用wait方法，释放仓库的对象锁，并使用notity唤醒生产者，生产者发现仓库的对象锁，又占有了它，并发现仓库空了，于是又开始生产……
代码如下：
这里仓库的容量设置为1，使用ArrayList来模拟仓库
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) throws Exception {
List list = new ArrayList();
Producer p = new Producer(list);
Consumer c = new Consumer(list);
p.start();
c.start();
}
}
class Producer extends Thread{
private List list;
public Producer(List list) {
this.list = list;
}
public Producer() {
}
public void run(){
while(true){
synchronized (list){
if(list.size()>0){
try {
//当前线程进入阻塞状态，并释放掉list的对象锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//若程序运行到这，说明仓库是空的
Object obj = new Object();
list.add(obj);
System.out.println("生产产品"+obj);
//唤醒被阻塞的消费者线程，但不会释放list对象锁，所以消费者还不会消费，只有当本synchronized代码块执行结束后才可以
list.notify();
}
}
}
}
class Consumer extends Thread{
private List list;
public Consumer(List list) {
this.list = list;
}
public Consumer() {
}
public void run(){
while(true){
synchronized (list){
if(list.size()==0){
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能够执行到此处，说明仓库中有商品
Object obj = list.remove(0);
System.out.println("消费产品"+obj);
//唤醒被阻塞的生产者线程，但不会释放list对象锁，所以生产者还不会生产，只有当本synchronized代码块执行结束后才可以
list.notify();
}
}
}
}运行结果如下
可以发现确实是生产一个产品 然后消费一个产品，然后循环往复
3496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
