进程简述
进程是一个应用程序，线程是一个进程中的执行场景/执行单元。进程和进程的内存独立不共享，线程和线程堆内存和方法区内存共享，但是栈内存不共享，一个线程一个栈，栈和栈之间互不干扰，这就是多线程并发。多线程机制就是为了提高工作效率。
eg：对于java程序来说，当在DOS命令窗口中输入:
java HelloWorld回车之后，会先启动JVM,而JVM就是一个进程，JVM再启动一个主线程调用main方法，
同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发：
一个是垃圾回收线程，一个是执行main方法的主线程。
线程的实现
要点
1、实现线程的第一种方式:编写一个类，直接继承java.lang.Thread,重写run方法。
//定义线程类
public class MyThread extends Thread {
public void run () {
}
}
//创建线程对象
MyThread t = new MyThread();
//启动线程
t.start();
2、实现线程的第二种方式:编写一个类，实现java.lang.Runnable接口，实现run方法。
//定义一个可运行的类
public class MyRunnable implements Runnable {
public void run() {
}
}
//创建线程对象
Thread t = new Thread (new MyRunnable ());
//启动线程
t.start();
第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。
3、线程的生命周期（重要 必会）
注意:
亘古不变的道理:
方法体当中的代码永远都是自上而下的顺序依次逐行执行的。
实例一
public class ThreadTest02 {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行。
//新建一个分支线程对象
MyThread myThread = new MyThread();
// myThread.run();//不会启动线程，没有新的分枝栈，还是在主栈中，没有并发。
//启动线程
//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 {
@Override
public void
run() {
// 编写程序,这段程序运行在分支线程中(分支栈)。
for(int i = 0; i < 1000; i++){
System.out.println("分支线程--->" + i);
}
}
}
内存图
实列二
public class ThreadTest01 {
public static void main(String[] args) {
//创建一个可运行的对象
//MyRunnable r = new MyRunnable();
//将可运行的对象封装成一个线程对象
//Thread t = new Thread(r); .
Thread t = new Thread(new MyRunnable()); //合并代码
//启动线程
t. start();
/*
//创建线程对象，采用匿名内部类方式
Thread t = new Thread(new Runnable(){
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("t线程---> "+ i);
}
}
});
*/
//这里的代码还是运行在主线程中。
for(int i = 0; i < 1000; i++){
System. out . println("主线程--->" + i);
}
}
}
//这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("分支线程2--->"+ i);
}
}
}
线程生命周期
线程的常用方法
要点
1、获取当前线程对象
Thread t = Thread.currentThread();
返回值t就是当前线程。
2、获取线程对象的名字
String name = 线程对象.getName();
3、修改线程对象的名字
线程对象.setName("线程名字");
4、当线程没有设置名字的时候,默认的名字有什么规律? (了解)
Thread-0
Thread-1
Thread-2
Thread-3
5、线程休眠sleep()
static void sleep(long millis)
1)、静态方法: Thread.sleep(1000);
2)、参数是毫秒
3)、作用:让当前线程进入休眠,进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中, A线程就会进入休眠。
这行代码出现在B线程中, B线程就会进入休眠。
4)、Thread.sleep()方法 ，可以做到这种效果:
间隔特定的时间，去执行一段特定的代码, 每隔多久执行一次。
6、终止睡眠interupt()
void interrupt()
t.interrupt();
7、强行终止线程stop(),直接将线程杀死，不安全，如果数据未保存，会丢失数据，已弃用。
java中和线程调度相关方法（了解）：
实例方法:
void setPriority(int newPriority) 设置线程的优先级
int getPriority()获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。(但也不完全是，大概率是多的)
静态方法:
static void yield() 线程让位
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从运行状态回到就绪状态。
注意:在回到就绪之后，有可能还会再次抢到。
实例方法:
void join() 合并线程
class MyThread1 extends Thread {
public void doSome () {
MyThread2 t = new MyThread2() ;
t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束，当前线程才可以继续
}
}
实例
public class ThreadTest03 {
public static void main(String[] args) {
//让当前线程进入休眠,睡眠5秒
//当前线程是主线程! ! !
/*try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//5秒之后执行这里的代码
Thread t = new Thread(new MyRunnable2()); .
t.setName("t");
t.start();
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//终断t线程的睡眠(这种终断睡眠的方式依靠了java的异常处理机制中断线程)
t.interrupt();
}
}
class MyRunnable2 implements Runnable {
//重点:run() 当中的异常不能throws，只能try catch
//因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---> begin");
try {
//睡眠1年
Thread.sleep(1000 * 60 * 60 * 24 * 365);
} catch (InterruptedException e) {
//打印异常信息
e.printStackTrace();
}
//1年之后才会执行这里
System.out.println(Thread.currentThread().getName() + "---> end");
}
}
实例二（合理终止线程）
public class ThreadTest02 {
public static void main(String[] args) {
MyRunable4 r = new MyRunable4();
Thread t = new Thread(r);
t.setName("t");
t.start();
//模拟5秒
try {
Thread.sleep( 5000);
} catch (InterruptedException e) {
e. printStackTrace();
}
//终止线程
//你想要什么时候终止的执行,那么你把标记修改为false ,就结束了。
r.isRunning = false;
}
}
class MyRunable4 implements Runnable {
//打一个布尔标记
boolean isRunning = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (isRunning) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
//终止 当前线程
//在结束之前需要保存的可以在这里保存save...
return;
}
}
}
}
线程安全（重点）
要点
1、为什么这个是重点?
以后在开发中，我们的项目都是运行在服务器当中,而服务器已经将线程的定义，
线程对象的创建，线程的启动等，都已经实现了。这些代码我们都不需要自己编写。
最重要的是:你要知道，你编写的程序需要放到一个多线程的环境下运行，
你更需要关注的是这些数据在多线程并发的环境下是否是安全的。
2、什么时候数据在多线程并发的环境下会存在安全问题呢?
三个条件:
条件1:多线程并发。
条件2:有共享数据。
条件3:共享数据有修改的行为。
满足以上3个条件之后，就会存在线程安全问题。
3、怎么解决线程安全问题呢?
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题。
怎么解决这个问题?
线程排队执行。(不能并发)。这种机制被称为:线程同步机制。
线程同步就是线程排队了，线程排队了就会牺牲一部分效率换取数据安全。
4、Java中有三大变量(重要)
实例变量:在堆中。
静态变量:在方法区。
局部变量:在栈中。
以上三大变量中:
局部变量永远都不会存在线程安全问题，
因为局部变量在栈中，永不共享。(一个线程一个栈。)
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量:不会有线程安全问题。
成员变量:可能会有线程安全问题。
5、如果使用局部变量的话:
建议使用: stringBuilder
因为局部变量不存在线程安全问题，stringBuilder是线程不安全的，效率较高。
stringBuffer是线程安全的，效率较低。
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap、Hashset是非线程安全的。
Hashtable是线程安全的。
...
6、synchronized有三种写法:
第一种:同步代码块
灵活
synchronized(线程共享对象) {
同步代码块;
}
第二种:在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。
第三种:在静态方法上使用synchronized
表示找类锁。
一个类一把类锁。
就算创建了100个对象，那类锁也只有一把 。
（对象锁: 一个对象一把对象锁，100个对象100把对象锁。）
7、我们以后开发中应该怎么解决线程安全问题?
是一上来就选择线程同步吗? synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量降低，体验差。在不得已的情况下再选择线程同步机制。
第一种方案:尽量使用局部变量代替“实例变量和静态变量”。
第二种方案:如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。(一个线程对应1个对象，100个 线程对应100个对象,
对象不共享，就没有数据安全问题了。)
第三种方案:如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了。线程同步机制。
synchronized同步机制
public class Account {
private String actno;
private double balance;
//取款
public void withdraw(double money){
//以下这几行代码必须是线程安全的，不能并发
//同步代码块越小效率越高
synchronized (this){//synchronized方法参数为需要排队线程的共享数据，不能为null
double before= this.getBalance();
double after=before-money;
//模拟网络延迟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
}
public class AccountThread extends Thread{
//共享账户
private Account act;
public AccountThread(Account act){
this.act=act;
}
public void run(){
//取款
double money=5000;
act.withdraw(money);
System.out.println(Thread.currentThread().getName()+"取款成功,余额"+act.getBalance());
}
}
public class AccountTest {
public static void main(String[] args) {
Account act = new Account("act-001",10000);
Thread t1 = new AccountThread(act);
Thread t2=new AccountThread(act);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
synchronized原理
死锁
/*
死锁情况并没有语法错误，一旦发生，既没有报错也没有异常，一直等待，很难检查。
*/
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2=new Object();
MyThread t=new MyThread(o1,o2);
MyThread2 t2=new MyThread2(o1,o2);
t.start();
t2.start();
}
}
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){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){
}
}
}
}
class MyThread extends Thread{
Object o1;
Object o2;
public MyThread(Object o1,Object o2){
this.o1=o1;
this.o2=o2;
}
public void run(){
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
}
}
}
}
线程补充
要点
1、守护线程
java语言中线程分为两大类:
一类是:用户线程
一类是:守护线程(后台线程)
其中具有代表性的就是:垃圾回收线程(守护线程)。
守护线程的特点:
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意:主线程main方法是一个用户线程。
守护线程用在什么地方呢?
每天00:00的时候系统数据自动备份。
这个需要使用到定时器，并且我们可以将定时器设置为守护线程，一直在那里看着，
没到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
守护线程实现方法：
setDaemon(true);
//一旦线程对象调用该方法，该线程就变成守护线程，哪怕是死循环也会在主线程结束时结束。
2、定时器
在java的类库中已经写好了一个定时器: java.util.Timer,可以直接拿来用。
不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
在实际的开发中，目前使用较多的是spring框架中提供的SpringTask框架,
这个框架只要进行简单的配置，就可以完成定时器的任务，底层其实还是用的Timer。
3、实现线程的第三种方式: FutureTask方式， 实现Callable接口。 ( JDK8新特性。)
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考:
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，
我们怎么能拿到这个执行结果呢?使用第三种方式:实现callable接口方式，call()方法相当于run()方法，只不过它有返回值。
4、关于Object类中的wait和notify方法。（生产者和消费者模式!）
第一: wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，
因为这两个方式是Object类中自带的。wait方法和notify方法不是通过线程对象调用，
不是这样的: t.wait(), 也不是这样的: t.notify()...不对。
第二: wait()方法作用?
Object O = new Object();
o.wait();
表示:
让正在o对象上活动的线程进入等待状态，无期限等待，直到被喚醒为止。
o.wait()方法的调用，会让"当前线程(正在o对象上活动的线程)进入等待状态。
第三: notify()方法作用?
Object O = new Object();
o.notify();
表示:
唤醒正在o对象上等待的线程。
还有一个notifyAll()方法:
这个方法是唤醒o对象上处于等待的所有线程。
o.wait()方法让正在o对象上活动的当前线程进入等待状态,并且释放之前占有的o对象的锁。
o.notify()方法唤醒正在o对象上等待的线程，只是通知，不会释放之前占有的o对象的锁。
实例一
public class TimerTest {
public static void main(String[] args) throws ParseException {
//创建一个定时器对象
Timer timer= new Timer();//timer相当于一个线程
//Timer timer = new Timer(true);//守护线程的方式
//指定定时任务
//timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime=sdf.parse("2021-03-14 18:46:30");
timer.schedule(new LogTimerTask(),firstTime,1000*10);//第一个参数可以用匿名内部类
}
}
//编写一个定时任务类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {
public void run(){
//编写需要执行的任务
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime+":成功完成了一次数据备份！");
}
}
实例二
public class ThreadTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建一个“未来人物类”对象
//参数非常重要，需要给一个Callable接口实现类对象
FutureTask task=new FutureTask(new Callable(){
public Object call() throws Exception{//call()方法相当于run方法，只不过有返回值
//线程执行一个任务，执行之后可能会有一个执行结果
//模拟执行
System.out.println("call method begin");
Thread.sleep(1000*10);
System.out.println("call method end!");
int a =100;
int b=200;
return a+b;
}
});
//创建一个线程对象
Thread t=new Thread(task);
//启动线程
t.start();
//这里是main方法,这是在主线程中。
//在主线程中，怎么获取t线程的返回结果?get()方法
// get()方法的执行会导致“当前线程阻塞”
Object obj=task.get();
System.out.println("线程执行结果："+obj);
// main方法这里的程序要想执行必须等待get()方法的结束
//而get()方法可能需要很久，因为get()方法是为了拿另一个线程的执行结果
//另一个线程执行是需要时间的，效率较低。
System.out.println("hello world!");
}
}
生产者和消费者模式
模拟生产者和消费者模式
public class ThreadTest04 {
/*
* 使用wait方法和notify方法实现生产者和消费者模式
* */
public static void main(String[] args) {
List list=new ArrayList();
//创建两个线程对象：生产者线程和消费者线程
Thread t1=new Thread(new Producer(list));
Thread t2=new Thread(new Consumer(list));
t1.setName("生产者线程");
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
//生产线程
class Producer implements Runnable{
private List list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
//一直生产
while (true) {
synchronized (list) {
if (list.size() > 0) {
//当前线程进入等待状态并释放list集合的锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能执行到这里说名明仓库是空的，可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "---->" + obj);
//唤醒消费者进行消费
list.notifyAll();
}
}
}
}
//消费线程
class Consumer implements Runnable{
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
//一直消费
while (true){
synchronized (list){
if(list.size()==0){
//仓库已经空了，消费者线程等待，释放掉list集合的锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序执行到此处说明仓库中有数据，消费者消费
Object obj= list.remove(0);
System.out.println(Thread.currentThread().getName()+"---->"+obj);
//唤醒生产者进行生产
list.notifyAll();
}
}
}
}
