进程和线程：

进程：

线程：

多线程的好处：

线程调度：

分时调度：

抢占式调度：

并发与并行：

线程的生命周期：

实现线程的两种基本方式（还有第三种）：

创建Thread线程类：

创建Runnable线程类：

相对于继承Thread类，实现Runnable接口创建多线程程序的好处：

用内部类和lambda表达式创建新线程：

Thread类常用的方法：

java中提供的和线程调度有关的方法：

合理的终止一个线程的执行：

关于Sleep()方法的面试题：

关于多线程并发环境下，数据的安全问题。

什么时候数据在多线程并发的环境下会存在安全问题呢？

怎么解决线程安全问题呢？

线程同步涉及到这两个专业术语：

线程不安全的情况：

如何使得线程安全：

同步代码块：

关于锁对象的研究：

同步代码块实现原理：

同步方法：

基于线程安全怎么选择该使用什么工具类：

synchronized面试题一：

synchronized面试题二：

synchronized面试题三：

synchronized面试题四：

死锁：

以后开发中应该怎么解决线程安全问题？

守护线程：

定时器：

实现线程的第三种方式：实现Callable接口（JDK8新特性）。

关于Object类中的wait和notify方法（生产者和消费者模式）：

线程间的通信：

线程的状态：

Lock锁：

线程池：

线程池的实现方法：

Java内置线程池的使用：

进程和线程：

进程：

进程是指在系统中正在运行的一个应用程序，程序一旦运行就是进程。

进程是系统进行资源分配的独立实体，且每个进程拥有独立的内存空间。

一个应用程序可以同时运行多个进程。

进程是程序的一个执行过程（如代码块），是系统运行程序的基本单位。

线程：

线程是进程中的一个执行单元，负责当前进程中程序的执行。

每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。

一个程序至少有一个进程，一个进程可以包含多个线程，每个线程使用其所属进程的栈空间。

Java代码中如果没有自定义线程类，那么有主线程（main线程）和垃圾收集线程。因为在运行Java程序的时候，会运行JVM，JVM会占用一个线程。

多线程的好处：

1、效率高。（多线程通过提高CPU利用率来提高效率。数据库访问、磁盘IO等操作的速度比CPU执行代码速度慢很多，单线程环境下，这些操作会阻塞程序执行，导致CPU空转，因此对于会产生这些阻塞的程序来说，使用多线程如果一个线程阻塞，CPU可以先去执行其他线程，避免在等待期间CPU的空转，提高CPU利用率。）

2、多个线程之间互不影响。（如果代码抛出了异常，只有一个线程停止了工作，其他线程可以继续执行）

线程调度：

分时调度：

所有线程轮流得到CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：

让优先级高的线程先使用CPU，如果多个线程之间的优先级相同，那么随机选择一个线程执行，Java使用的是抢占式调度。

另外，在java语言中：多个线程共享同一个堆内存和方法区内存。但是栈内存独立，一个线程一个栈，互不干扰。

再者，不管main方法调用了几个方法，只要它还是一个栈，那就只有一个线程。

思考一个问题：使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？

不会。main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在
压栈弹栈。

并发与并行：

并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨同时在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两个大一点得坑，一定会用两个小时。

并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在（当进程的数量大于CPU时，计算机就无法同时执行多个线程，也就是并行，这时候又会转入并发状态，一个CPU高速轮转执行多个线程）。

并发是并行的假象（每个小时间片执行一个操作，多个操作快速切换执行）。

线程的生命周期：

实现线程的两种基本方式（还有第三种）：

创建Thread线程类。
创建Runnable线程类。

创建Thread线程类：

Java创建并启动Thread多线程的步骤如下：

创建一个Thread类的继承类。
在继承类中重写Thread类的run方法，设置线程任务。（当开启这个线程后，JVM自动调用该方法）
创建Thread子类的实例，即创建了线程对象。
调用线程对象的start()方法来启动该线程。

注意：多次启动同一个线程是非法的，特别是在该线程关闭了之后。

Java的线程调度是抢占式调度。（同一优先级下，多个线程同时抢占CPU的控制权，代码的执行顺序是不确定的）

class MyThread extends Thread{private String name;public MyThread(String name) {this.name = name;}@Overridepublic void run() {for(int i = 0 ; i < 50 ; i++) {System.out.println(this.name + "正在工作中……" + i);}}
}public class testThread {public static void main(String[] args) {// 实例化线程对象MyThread mt1 = new MyThread("线程一");MyThread mt2 = new MyThread("线程二");MyThread mt3 = new MyThread("线程三");// 启动实例线程对象mt1.start();mt2.start();mt3.start();}
}

输出结果：

当调用start()方法时，Java会开辟一个新的栈空间，并在新的栈空间中调用线程类的run()方法。

/*
实现线程的第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。怎么创建线程对象？ new就行了。怎么启动线程呢？ 调用线程对象的start()方法。注意：亘古不变的道理：方法体当中的代码永远都是自上而下的顺序依次逐行执行的。t.run();执行完main方法中的循环才会执行，但因为它开启了一个分支栈，所有MyThread和main两个线程同时执行同时循环输出为抢占式调度。*/
public class ThreadTest02 {public static void main(String[] args) {// 这里是main方法，这里的代码属于主线程，在主栈中运行。// 新建一个分支线程对象MyThread t = new MyThread();// 启动线程// t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）// start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。// t.start();这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。// run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。t.start();// 这里的代码还是运行在主线程中。for(int i = 0; i < 1000; i++){System.out.println("主线程--->" + i);}}
}class MyThread extends Thread {@Overridepublic void run() {// 编写程序，这段程序运行在分支线程中（分支栈）。for(int i = 0; i < 1000; i++){System.out.println("分支线程--->" + i);}}
}

创建Runnable线程类：

Java创建并启动Thread多线程的步骤如下：

创建一个Runnable接口的实现类。
在实现类中重写Runnable接口的run方法，设置线程任务。
创建一个Runnable接口的实现类对象（即创建Runnable实现类对象）。
创建Thread类对象，在构造方法中传递Runnable接口的实现类对象。
调用Thread类中的start方法，开启新的线程执行run方法。

注意：Runnable接口并没有start()方法，要通过调用Thread类的构造方法才能运行新线程。

Thread(Runnable target); 直接传递Runnable实现类对象。

Thread(Runnable target, String name); 传递Runnable实现类对象，并给该线程定义一个名称。

/*
实现线程的第二种方式，编写一个类实现java.lang.Runnable接口。*/
public class ThreadTest03 {public static void main(String[] args) {// 创建一个可运行的对象//MyRunnable r = new MyRunnable();// 将可运行的对象封装成一个线程对象//Thread t = new Thread(r);Thread t = new Thread(new MyRunnable()); // 合并代码// 启动线程t.start();for(int i = 0; i < 100; i++){System.out.println("主线程--->" + i);}}
}// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {@Overridepublic void run() {for(int i = 0; i < 100; i++){System.out.println("分支线程--->" + i);}}
}

相对于继承Thread类，实现Runnable接口创建多线程程序的好处：

1、避免了单继承的局限性：

一个类只能继承一个类，类继承了Thread类就不能继承其他的类。而实现了Runnable接口，还可以继承其他的类，实现其他的接口。

2、增强了程序的扩展性，降低了程序的耦合性(解耦)：

实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)。

public class Demo {public void a(Runnable runnable){new MyThread().start();     // 这里就固定死了，只能创建MyThread类的线程。Thread thread = new Thread(Runnable r);   // 解耦，根据传过来的不同的Runnable实现类，创建不同类的线程}
}

3、如果一个类继承了Thread类，则不适合资源共享。但如果是实现类Runnable接口，则很容易资源共享。

4、线程池只能放实现类Runnable或Callable接口的类线程，不能直接放继承了Thread的类线程。

用内部类和lambda表达式创建新线程：

Runnable接口是一个函数式接口，可以使用lambda表达式。

// 匿名内部类的方式
public class Demo {public static void main(String[] args){new Thread(){@Overridepublic void run() {System.out.println("线程1");}}.start();new Thread(new Runnable(){@Overridepublic void run() {System.out.println("线程2");}}).start();// lambda表达式的方式/*lambda表达式创建Runnable实例对象：Runnable runnable = ()->{System.out.println();};Thread类中的一个构造方法：public Thread(Runnable target) {init(null, target, "Thread-" + nextThreadNum(), 0);}*/new Thread(()->{System.out.println();});}
}

Thread类常用的方法：

构造方法：

Thread(); 创建一个线程类对象。

Thread(String name); 创建一个线程类对象，名称为name。（可以在自定义的线程类中定义一个含参的构造方法，其中调用父类的构造方法，这样我们就可以在new线程类的对象的时候就定义该线程的名称）

Thread(Runnable target); 稍后介绍。

Thread(Runnable target, String name); 稍后介绍。

静态方法：

static Thread currentThread();        返回调用该方法的线程的引用，返回类型为Thread。

static sleep(long millis);        以指定毫秒数暂停该线程的执行。sleep会抛出异常。

实例方法：

void start();        启动已创建的线程对象。

void run();        由线程调度器调用，当从run()返回时，该线程运行结束。

final void setName(String name);        设置线程的名字。

final String getName();        返回线程的名字。（默认第一个为Thread-0，第二个为Thread-1.......）。

interrupt();        中断线程对象所处的状态。如果线程处于阻塞状态，调用该方法会使阻塞状态结束而进入就绪状态。此方法会抛出InterruptedException异常。

fianl boolean isAlive();        判断线程是否被启动，若被启动则返回true。

stop();   强制终止线程（已过时，不建议使用）（可能会丢失数据）

currentThread()方法常常搭配getName()方法来获得当前执行的线程名称。

（getName()是静态方法，可直接在继承Thread类的线程类中使用。而main方法没有继承Thread类，所有如果要得到main方法的线程名称（main），需要currentThread().getName()组合使用）

java中提供的和线程调度有关的方法：

实例方法：
void setPriority(int newPriority) 设置线程的优先级

int getPriority() 获取线程优先级

最低优先级1（常量MIN_PRIORITY）

默认优先级是5（常量NORM_PRIORITY）

最高优先级10（常量MAX_PRIORITY）

优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）

静态方法：
static void yield() 让位方法

使当前正在运行的线程暂时中断，变为就绪状态

暂停当前正在执行的线程对象，并执行其他线程

yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。

yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。

注意：在回到就绪之后，有可能还会再次抢到。

实例方法：
void join()
使当前线程暂停运行，等调用join方法的线程运行结束，当前线程才继续运行。也称为合并线程。

class MyThread1 extends Thread {public void doSome(){MyThread2 t = new MyThread2();t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。}
}class MyThread2 extends Thread{}

合理的终止一个线程的执行：

/*
怎么合理的终止一个线程的执行。这种方式是很常用的。*/
public class ThreadTest10 {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();}// 终止线程// 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。r.run = false;}
}class MyRunable4 implements Runnable {// 打一个布尔标记boolean run = true;@Overridepublic void run() {for (int i = 0; i < 10; i++){if(run){System.out.println(Thread.currentThread().getName() + "--->" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}else{// return就结束了，你在结束之前还有什么没保存的。// 在这里可以保存呀。//save....//终止当前线程return;}}}
}

关于Sleep()方法的面试题：

/*
关于Thread.sleep()方法的一个面试题：*/
public class ThreadTest07 {public static void main(String[] args) {// 创建线程对象Thread t = new MyThread3();t.setName("t");t.start();// 调用sleep方法try {// 问题：这行代码会让线程t进入休眠状态吗？t.sleep(1000 * 5); // 在执行的时候还是会转换成：Thread.sleep(1000 * 5);// 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。// 这样代码出现在main方法中，main线程睡眠。} catch (InterruptedException e) {e.printStackTrace();}// 5秒之后这里才会执行。System.out.println("hello World!");}
}class MyThread3 extends Thread {public void run(){for(int i = 0; i < 10000; i++){System.out.println(Thread.currentThread().getName() + "--->" + i);}}
}

关于多线程并发环境下，数据的安全问题。

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。我们只需要知道，我们编写的程序放到一个多线程的环境下运行，所涉及到的数据在多线程并发的环境下是否是安全的。

什么时候数据在多线程并发的环境下会存在安全问题呢？

三个条件：

条件1：多线程并发。

条件2：有共享数据。

条件3：共享数据有修改的行为。

满足以上3个条件之后，就会存在线程安全问题。

怎么解决线程安全问题呢？

当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？

线程排队执行。（不能并发）。用排队执行解决线程安全问题。

这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。线程排队了会牺牲一部分效率，但没办法，数据安全是第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

线程同步涉及到这两个专业术语：

异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）

同步编程模型：

线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。

线程不安全的情况：

当多个线程共享一个数据时，如果两个线程同时拿到了这个数据的修改权，当一个线程把其中一个数据修改了，那么另一个线程将只能使用这个被修改过后的数据，这就导致了不安全。

下列示例取款代码就是一个线程不安全的代码：

/*测试类、main类*/
public class Test {public static void main(String[] args) {// 创建账户对象（只创建1个）Account act = new Account("act-001", 10000);// 创建两个线程Thread t1 = new AccountThread(act);Thread t2 = new AccountThread(act);// 设置namet1.setName("t1");t2.setName("t2");// 启动线程取款t1.start();t2.start();}
}

/*线程类*/
public class AccountThread extends Thread {// 注意：两个线程对同一个账户对象进行操作！！！！！！private Account act;// 通过构造方法传递过来账户对象public AccountThread(Account act) {this.act = act;}public void run(){// run方法的执行表示取款操作。// 假设取款5000double money = 5000;// 取款// 多线程并发执行这个方法。act.withdraw(money);System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());}
}

/*
银行账户类不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。*/
public class Account {// 账号private String actno;// 余额private double balance;public Account() {}public Account(String actno, double balance) {this.actno = actno;this.balance = balance;}public String getActno() {return actno;}public void setActno(String actno) {this.actno = actno;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}//取款的方法public void withdraw(double money){// t1和t2并发这个方法。。。。（t1和t2是两个栈。两个栈操作堆中同一个对象。）// 取款之前的余额double before = this.getBalance(); // 10000// 取款之后的余额double after = before - money;// 在这里模拟一下网络延迟，100%会出现问题try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// 更新余额// 思考：t1执行到这里了，但还没有来得及执行setBalance这行代码，t2线程进来withdraw方法了。// 查询到余额还是10000，此时一定出问题。this.setBalance(after);}
}

如何使得线程安全：

同步代码块：

语法格式：

synchronized (锁对象) {可能会出现线程安全问题的代码(访问了共享数据的代码)// 线程同步代码块
}

锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行。

synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据，才能达到多线程排队。

()中写什么？那要看你想让哪些线程同步。

假设t1、t2、t3、t4、t5，有5个线程，你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？

你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。

注意:

1、同步代码块代码块中的锁对象，可以使用任意的对象。（一般为Object对象）

2.、必须保证多个线程使用的锁对象是同一个。

3、锁对象一般要定义在run()方法的外部，因为一旦定义在run()方法的内部，那么每个线程都有自己独有的锁对象，那么就起不到线程安全的作用了。

4、同步代码块内部所要执行的代码越少，效率越高。

代码示例（改进上述有问题的代码）：

/*
银行账户类不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。*/
public class Account {// 账号private String actno;// 余额private double balance;public Account() {}public Account(String actno, double balance) {this.actno = actno;this.balance = balance;}public String getActno() {return actno;}public void setActno(String actno) {this.actno = actno;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}//取款的方法public void withdraw(double money){synchronized(this){    // 因为对象是共享的，多个线程共享一个账户对象，可以把this作为锁对象// 不一定是this，这里只要是多线程共享的那个对象就行。double before = this.getBalance();double after = before - money;try {Thread.sleep(1000);} catch (InterruptedException e) {    e.printStackTrace();}this.setBalance(after);}}
}

另外，Java有三大变量：

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

以上三大变量中：
局部变量永远都不会存在线程安全问题。因为局部变量不共享。（一个线程一个栈。）
常量也不会存在线程安全问题，因为常量不可修改。

关于锁对象的研究：

/*
银行账户使用线程同步机制，解决线程安全问题。*/
public class Account {// 账号private String actno;// 余额private double balance; //实例变量。//对象Object obj = new Object(); // 实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）public Account() {}public Account(String actno, double balance) {this.actno = actno;this.balance = balance;}public String getActno() {return actno;}public void setActno(String actno) {this.actno = actno;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}//取款的方法public void withdraw(double money){//Object obj2 = new Object();synchronized (this){//synchronized (obj) {  // 可以//synchronized ("abc") { // "abc"在字符串常量池当中，只要一个，可以。// 但注意，如果是字符串的形式，那么所有账户不论是不是同一个都不能并发了// 因为都指向同一个字符串常量对象// 但用this就不会出现这样的问题//synchronized (null) { // 报错：空指针。//synchronized (obj2) { // 这样编写就不安全了。因为obj2是局部变量，不是共享对象。double before = this.getBalance();double after = before - money;try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}this.setBalance(after);}}
}

同步代码块实现原理：

锁对象又称为同步锁、对象锁、对象监视器。

3个线程一起抢夺cpu的执行权,谁抢到了谁执行run方法，遇到synchronized代码块后，线程会检查synchronized代码块是否有锁对象，如果有，就会获取到锁对象，进入到同步中执行。

如果其他线程执行run方法时发现synchronized代码块的锁对象被取走了，就会进入到阻塞状态，一直等待执行中的线程归还锁对象。

线程执行完同步中的代码，会把锁对象归还给同步代码块，下一个线程就可以获得锁对象进入到同步中执行代码。

同步中的线程没有执行完毕不会释放锁，同步外的线程没有锁进不去同步。

缺陷：程序频繁的判断锁，获取锁，释放锁，程序的效率会降低。

同步方法：

语法格式：

修饰符列表 synchronized 返回值类型 方法名(参数列表){可能会出现线程安全问题的代码(访问了共享数据的代码)}

注意，synchronized修饰实例方法时，锁对象就是this，不灵活。

特别的，当同步方法是静态的时候，静态方法的锁对象是本类的class属性（是class文件本身）。又称为类锁。

类锁永远只有1把。

就算创建了100个该类的对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。

类锁：100个对象，也可能只是1把类锁。

（注意，当同步方法是静态的时候，不能访问类中的实例字段，因为实例字段在new对象的时候才会产生，而静态方法在类加载的时候就产生了，就会引用一个不存在的字段，Java会报错）

基于线程安全怎么选择该使用什么工具类：

如果使用局部变量的话：

建议使用：StringBuilder。因为局部变量不存在线程安全问题。如果选择StringBuilder，StringBuffer效率比较低。

另外：

ArrayList是非线程安全的。Vector是线程安全的。

HashMap、HashSet是非线程安全的。Hashtable是线程安全的。

synchronized面试题一：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？//不需要，因为doOther()方法没有synchronized
public class Exam01 {public static void main(String[] args) throws InterruptedException {MyClass mc = new MyClass();Thread t1 = new MyThread(mc);Thread t2 = new MyThread(mc);t1.setName("t1");t2.setName("t2");t1.start();Thread.sleep(1000); //这个睡眠的作用是：让main方法进入休眠，以保证t1线程先执行。t2.start();}
}class MyThread extends Thread {private MyClass mc;public MyThread(MyClass mc){this.mc = mc;}public void run(){if(Thread.currentThread().getName().equals("t1")){mc.doSome();}if(Thread.currentThread().getName().equals("t2")){mc.doOther();}}
}class MyClass {public synchronized void doSome(){System.out.println("doSome begin");try {Thread.sleep(1000 * 10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("doSome over");}public void doOther(){System.out.println("doOther begin");System.out.println("doOther over");}
}

synchronized面试题二：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？//需要,因为锁住的是同一个对象
public class Exam01 {public static void main(String[] args) throws InterruptedException {MyClass mc = new MyClass();Thread t1 = new MyThread(mc);Thread t2 = new MyThread(mc);t1.setName("t1");t2.setName("t2");t1.start();Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。t2.start();}
}class MyThread extends Thread {private MyClass mc;public MyThread(MyClass mc){this.mc = mc;}public void run(){if(Thread.currentThread().getName().equals("t1")){mc.doSome();}if(Thread.currentThread().getName().equals("t2")){mc.doOther();}}
}class MyClass {public synchronized void doSome(){System.out.println("doSome begin");try {Thread.sleep(1000 * 10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("doSome over");}public synchronized void doOther(){System.out.println("doOther begin");System.out.println("doOther over");}
}

synchronized面试题三：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？//不需要，因为锁住的是两个不相同的对象
public class Exam01 {public static void main(String[] args) throws InterruptedException {MyClass mc1 = new MyClass();MyClass mc2 = new MyClass();Thread t1 = new MyThread(mc1);Thread t2 = new MyThread(mc2);t1.setName("t1");t2.setName("t2");t1.start();Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。t2.start();}
}class MyThread extends Thread {private MyClass mc;public MyThread(MyClass mc){this.mc = mc;}public void run(){if(Thread.currentThread().getName().equals("t1")){mc.doSome();}if(Thread.currentThread().getName().equals("t2")){mc.doOther();}}
}class MyClass {public synchronized void doSome(){System.out.println("doSome begin");try {Thread.sleep(1000 * 10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("doSome over");}public synchronized void doOther(){System.out.println("doOther begin");System.out.println("doOther over");}
}

synchronized面试题四：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？//需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。
public class Exam01 {public static void main(String[] args) throws InterruptedException {MyClass mc1 = new MyClass();MyClass mc2 = new MyClass();Thread t1 = new MyThread(mc1);Thread t2 = new MyThread(mc2);t1.setName("t1");t2.setName("t2");t1.start();Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。t2.start();}
}class MyThread extends Thread {private MyClass mc;public MyThread(MyClass mc){this.mc = mc;}public void run(){if(Thread.currentThread().getName().equals("t1")){mc.doSome();}if(Thread.currentThread().getName().equals("t2")){mc.doOther();}}
}class MyClass {// synchronized出现在静态方法上是找类锁。public synchronized static void doSome(){System.out.println("doSome begin");try {Thread.sleep(1000 * 10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("doSome over");}public synchronized static void doOther(){System.out.println("doOther begin");System.out.println("doOther over");}
}

死锁：

在开发中synchronized最好不要嵌套使用，一不小心就会导致死锁的产生。

以下代码中，线程一要先锁住对象o1然后再锁住对象o2才能完成任务，而线程二要先锁住对象o2然后再锁住对象o1才能完成任务。在线程一锁住o1但还未锁住o2的时候，倘若线程二锁住了o2，那么程序将无法执行下去，这种现象被称为死锁。

死锁不会报错，很难调试，只能尽量避免。

public class DeadLock {public static void main(String[] args) {Object o1 = new Object();Object o2 = new Object();// t1和t2两个线程共享o1,o2Thread t1 = new MyThread1(o1,o2);Thread t2 = new MyThread2(o1,o2);t1.start();t2.start();}
}class MyThread1 extends Thread{Object o1;Object o2;public MyThread1(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 MyThread2 extends Thread {Object o1;Object o2;public MyThread2(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){}}}
}

以后开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量（并发量）降低。用户体验差。在不得已的情况下再选择线程同步机制。

第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了，使用线程同步机制。

守护线程：

java语言中线程分为两大类：

一类是：用户线程

一类是：守护线程（后台线程），其中具有代表性的就是：垃圾回收线程（守护线程）。

守护线程的特点：

一般守护线程是一个死循环，且所有的用户线程只要结束，守护线程自动结束。

注意：主线程main方法是一个用户线程。

守护线程用在什么地方呢？
如系统数据自动备份，这个需要使用到定时器，我们可以将定时器设置为守护线程。一直运行，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，因为没有必要进行数据备份了。

/*
守护线程*/
public class ThreadTest14 {public static void main(String[] args) {Thread t = new BakDataThread();t.setName("备份数据的线程");// 启动线程之前，将线程设置为守护线程t.setDaemon(true);t.start();// 主线程：主线程是用户线程for(int i = 0; i < 10; i++){System.out.println(Thread.currentThread().getName() + "--->" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}class BakDataThread extends Thread {public void run(){int i = 0;// 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。while(true){System.out.println(Thread.currentThread().getName() + "--->" + (++i));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

定时器：

定时器的作用：

间隔特定的时间，执行特定的程序。

在java中其实可以采用多种方式实现：

可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。

另外在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。

目前实际的开发中使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;/*
使用定时器指定定时任务。*/
public class TimerTest {public static void main(String[] args) throws Exception {// 创建定时器对象Timer timer = new Timer();    // 默认是普通线程//Timer timer = new Timer(true); //守护线程的方式// 指定定时任务//timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date firstTime = sdf.parse("2020-03-14 09:34:30");//timer.schedule(new LogTimerTask() , firstTime, 1000 * 10);// 每年执行一次。//timer.schedule(new LogTimerTask() , firstTime, 1000 * 60 * 60 * 24 * 365);//匿名内部类方式timer.schedule(new TimerTask(){@Overridepublic void run() {// code....}} , firstTime, 1000 * 10);}
}// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {@Overridepublic void run() {// 编写你需要执行的任务就行了。SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String strTime = sdf.format(new Date());System.out.println(strTime + ":成功完成了一次数据备份！");}
}

实现线程的第三种方式：实现Callable接口（JDK8新特性）。

这种方式实现的线程可以获取线程的返回值。之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。/*
实现线程的第三种方式：实现Callable接口这种方式的优点：可以获取到线程的执行结果。这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。*/
public class ThreadTest15 {public static void main(String[] args) throws Exception {// 第一步：创建一个“未来任务类”对象。// 参数非常重要，需要给一个Callable接口实现类对象。FutureTask task = new FutureTask(new Callable() {@Overridepublic 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; //自动装箱(300结果变成Integer)}});// 创建线程对象Thread t = new Thread(task);// 启动线程t.start();// 这里是main方法，这是在主线程中。// 在主线程中，怎么获取t线程的返回结果？// get()方法的执行会导致“当前线程阻塞”Object obj = task.get();System.out.println("线程执行结果:" + obj);// main方法这里的程序要想执行必须等待get()方法的结束// 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果// 另一个线程执行是需要时间的。System.out.println("hello world!");}
}

关于Object类中的wait和notify方法（生产者和消费者模式）：

注意：

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。wait方法和notify方法不是通过线程对象调用。

第二：wait()方法作用？

    Object o = new Object();o.wait();

上述代码表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。

第三：notify()方法作用？

    Object o = new Object();o.notify();

上述代码表示：唤醒正在o对象上等待的线程。

另外还有一个notifyAll()方法：

这个方法是唤醒o对象上处于等待的所有线程。

import java.util.ArrayList;
import java.util.List;/*
1、使用wait方法和notify方法实现“生产者和消费者模式”2、什么是“生产者和消费者模式”？生产线程负责生产，消费线程负责消费。生产线程和消费线程要达到均衡。这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。4、wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。5、wait方法作用：o.wait()让正在o对象上活动的线程t（调用wait()的线程）进入等待状态，并且释放掉t线程（调用wait()的线程）之前占有的o对象的锁。你陷入无休止的等待状态，就不能一直让别的线程等你们归还锁，不能占着茅坑不拉屎。6、notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。notify()之后，消费者和生产者都可以抢这个锁，就会出现消费者消费完后继续抢到生产者的锁的情况，但因为加了判断，仓库为空，消费者会执行wait()方法依然还是会把抢来的锁还给生产者。7、模拟这样一个需求：仓库我们采用List集合。List集合中假设只能存储1个元素。1个元素就表示仓库满了。如果List集合中元素个数是0，就表示仓库空了。保证List集合中永远都是最多存储1个元素。必须做到这种效果：生产1个消费1个。*/
public class ThreadTest16 {public static void main(String[] args) {// 创建1个仓库对象，共享的。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;}@Overridepublic void run() {// 一直生产（使用死循环来模拟一直生产）while(true){// 给仓库对象list加锁。synchronized (list){if(list.size() > 0){ // 大于0，说明仓库中已经有1个元素了。try {// 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。list.wait();} catch (InterruptedException e) {e.printStackTrace();}}// 程序能够执行到这里说明仓库是空的，可以生产Object obj = new Object();list.add(obj);System.out.println(Thread.currentThread().getName() + "--->" + obj);// 唤醒消费者进行消费list.notify();// 即便是list.notifyAll();也没事，因为另一个线程正卡在wait()那一行，// 唤醒之后本方法结束，归还锁后另一个线程得到锁开始执行本线程又在等待锁}}}
}// 消费线程
class Consumer implements Runnable {// 仓库private List list;public Consumer(List list) {this.list = list;}@Overridepublic void run() {// 一直消费while(true){synchronized (list) {if(list.size() == 0){try {// 仓库已经空了。// 消费者线程等待，释放掉list集合的锁list.wait();} catch (InterruptedException e) {e.printStackTrace();}}// 程序能够执行到此处说明仓库中有数据，进行消费。Object obj = list.remove(0);System.out.println(Thread.currentThread().getName() + "--->" + obj);// 唤醒生产者生产。list.notify();// 即便是list.notifyAll();也没事，因为另一个线程正卡在wait()那一行，// 唤醒之后本方法结束，归还锁后另一个线程得到锁开始执行本线程又在等待锁}}}
}

线程间的通信：

等待唤醒机制可用于达到线程之间的通信：

import java.util.ArrayList;
import java.util.List;public class TestSync {public static void main(String[] args) {// 定义一个锁对象Object lock = new Object();List<String> list = new ArrayList<>();// 实现线程AThread threadA = new Thread(() -> {synchronized (lock) {for (int i = 1; i <= 10; i++) {list.add("abc");System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}if (list.size() == 5)lock.notify();// 唤醒B线程}}});// 实现线程BThread threadB = new Thread(() -> {while (true) {synchronized (lock) {if (list.size() != 5) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("线程B收到通知，开始执行自己的业务...");}}});//　需要先启动线程BthreadB.start();// 再启动线程AthreadA.start();}
}

线程的状态：

sleep()是Thread类的一个静态方法。

wait()方法也可以传递一个long类型的参数，表示等待的毫秒数，达到的效果与sleep()方法一致。

sleep()方法不释放锁，wait()方法释放锁，其他程序可夺取该线程的锁。

wait()和notify()是Object类的一个实例方法，必须由锁对象进行调用。（任意锁对象都继承了Object类，都能调用该方法）在哪个线程中调用了wait()方法，那就哪个线程进入等待状态，当其他线程调用notify()方法后，原线程被唤醒，进入运行状态或阻塞状态。

当调用notify()方法唤醒一个线程时，该线程将继续执行wait()方法之后的代码。如果有多个线程都用同一个锁对象进入等待状态，那么在调用notify()方法唤醒线程时，将随机唤醒一个线程。

使用notifyAll()方法可以同时唤醒所有使用该锁对象进入等待状态的线程。

wait和 notify只能在同步代码块或同步方法中使用。

wait()方法会抛出一个InterruptedException异常，这个异常必须捕获，不能再声明抛出，因为run()方法并没有抛出异常，我们要重写run()方法，那就也不能抛出异常。

Lock锁：

java.util.concurrent.locks下有一个Lock接口，提供了比使用 synchronized 方法和语句更广泛的锁定操作。

Lock接口中的常用方法：

void lock(); 获取锁。

void unlock(); 释放锁。

java.util.concurrent.locks.Reentrantlock类实现了Lock接口，可直接调用。

使用步骤:

1、在可能会出现安全问题的代码外部创建一个ReentrantLock对象。

2、在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁。

3、在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁。

代码示例：

class RunnableImpl implements Runnable{int ticket=100;Lock lock = new ReentrantLock();@Overridepublic void run() {lock.lock();while (true){System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");ticket--;if(ticket==0){break;}}lock.unlock();}}

特别的，可以把unlock方法放到finally语句中，这样无论其中的语句是否出现异常，都会释放锁，保证了下一个线程可以执行。

class RunnableImpl implements Runnable{int ticket=100;Lock lock = new ReentrantLock();@Overridepublic void run() {lock.lock();try {while (true){System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");ticket--;if(ticket==0){break;}}}finally {lock.unlock();    }}}

线程池：

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务?

在Java中可以通过线程池来达到这样的效果。

线程池的实现方法：

当程序第一次启动的时候创建多个线程保存到一个集合中，如LinkedList<Thread>，当我们想要使用线程的时候，就可以从集合中取出来线程使用：

Thread t = list.remove(0);        // 返回的是被移除的元素(线程只能被一个任务使用)

当我们使用完毕线程,需要把线程归还给线程池：

list.add(t);

合理利用线程池能够带来好处：

1、降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

2、提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

3、提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存而把服务器累趴下（每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机）。

在JDK1.5之后，Java中已经内置了一个线程池，我们可以直接使用。

Java内置线程池的使用：

java.util.concurrent 包下有一个 Executors 类，是线程池的工厂类，用来生成线程池。

Executors 类中的静态方法：

static ExecutorService newFixedThreadPool(int nThreads); 创建一个可重用固定线程数的线程池。

参数： int nThreads，创建线程池中包含的线程数量。
返回值： ExecutorService接口，返回的是ExecutorService接口的实现类对象。我们可以使用ExecutorService接口接收（面向接口编程）

java.util.concurrent.ExecutorService：线程池接口。内置有用来从线程池中获取线程的方法。

submit(Runnable task); 提交一个 Runnable 的实现类对象给线程池，让线程池中的一个线程按照实现类的代码执行任务。

void shutdown(); 用于执行关闭/销毁线程池的方法。

以上方法均是用工厂方法返回的ExecutorService类的对象进行调用。

线程池的使用步骤：

1、使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池。

2、创建一个类，实现Runnable接口，重写run方法，设置线程任务。

3、把Runnable的一个实现类对象作为实参调用ExecutorService中的submit()方法，传递线程任务，开启线程，执行实现类的run方法。

4、调用ExecutorService中的方法shutdown销毁线程池(不建议执行)。

注意：

1、线程池的线程执行完Runnable实现类的run()方法后，会自动返回线程池中。当线程池中的线程数不足以支撑所有的线程调用时，线程的调用会等待，等待一个完成了任务的线程返回线程池中，再用该线程执行新任务。

2、线程池会一直在执行，代码不会停止，如果想让代码停止，须调用shutdowm()方法。线程池销毁后如果继续调用线程池的submit()方法会抛出一个异常。

代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Demo {public static void main(String[] args) {ExecutorService ex = Executors.newFixedThreadPool(2);ex.submit(new ESimpl());ex.submit(new ESimpl());ex.submit(new ESimpl());ex.shutdown();}
}class ESimpl implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"正在执行任务");}
}

多线程、并发/并行、自定义线程类、线程安全、守护线程、定时器、线程状态、线程池相关推荐

多CPU/多核/多进程/多线程/并发/并行之间的关系
多CPU,多核,多进程,多线程当面临这些问题的时候,有两个关键词无法绕开,那就是并行和并发. 首先,要先了解几个概念: 1.进程是程序的一次执行. 2.进程是资源分配的基本单位(调度单位). 3.一 ...
Delphi中的线程类
Delphi中有一个线程类TThread是用来实现多线程编程的,这个绝大多数Delphi书藉都有说到,但基本上都是对TThread类的几个成员作一简单介绍,再说明一下Execute的实现和Synchr ...
Delphi线程类的使用(1)
Delphi线程类的使用猛禽[Mental Studio](个人专栏)(BLOG) http://mental.mentsu.com 去年底我写过一篇文章<Delphi中的线程类.2.3.4. ...
DELPHI 线程类
转自http://www.cnblogs.com/chengxin1982/archive/2009/10/04/1577879.html Delphi中有一个线程类TThread是用来实现多线程编程 ...
重点：怎样正确的使用QThread类（注：包括推荐使用QThread线程的新方法QObject::moveToThread）...
背景描述: 以前,继承 QThread 重新实现 run() 函数是使用 QThread唯一推荐的使用方法.这是相当直观和易于使用的.但是在工作线程中使用槽机制和Qt事件循环时,一些用户使用错了.Qt ...
Delphi中的线程类--之（2）
Delphi中的线程类猛禽[Mental Studio] http://mental.mentsu.com 之二首先就是构造函数: constructor TThread.Create(Creat ...
Java 多线程 | 并发知识面试问答总结
写在最前面这个项目是从20年末就立好的 flag,经过几年的学习,回过头再去看很多知识点又有新的理解.所以趁着找实习的准备,结合以前的学习储备,创建一个主要针对应届生和初学者的 Java 开源知识项 ...
【成神之路】多线程并发相关面试题
基本概念: 说说线程安全问题,什么是线程安全,如何保证线程安全函数.函数库在并发环境中被调用时,能够正确地处理多个线程之间的共享变量,使程序功能正确完成. 代码在多线程下执行和在单线程下执行永远都能 ...
多线程并发知识，肝完这篇10W+字超详细的文章就够了
大家好,我是Oldou,今天又到了我们的学习时间了,本文介绍的是多线程相关的知识,文中的内容可能不是很全,但是学习完一定会让自己掉发升级,内容比较多,但是我们千万别放弃,不懂的地方一定要主动花时间去理 ...

多线程、并发/并行、自定义线程类、线程安全、守护线程、定时器、线程状态、线程池

进程和线程：

进程：

线程：

多线程的好处：

线程调度：

分时调度：

抢占式调度：

并发与并行：

线程的生命周期：

实现线程的两种基本方式（还有第三种）：

创建Thread线程类：

创建Runnable线程类：

相对于继承Thread类，实现Runnable接口创建多线程程序的好处：

用内部类和lambda表达式创建新线程：

Thread类常用的方法：

java中提供的和线程调度有关的方法：

合理的终止一个线程的执行：

关于Sleep()方法的面试题：

关于多线程并发环境下，数据的安全问题。

什么时候数据在多线程并发的环境下会存在安全问题呢？

怎么解决线程安全问题呢？

线程同步涉及到这两个专业术语：

线程不安全的情况：

如何使得线程安全：

同步代码块：

关于锁对象的研究：

同步代码块实现原理：

同步方法：

基于线程安全怎么选择该使用什么工具类：

synchronized面试题一：

synchronized面试题二：

synchronized面试题三：

synchronized面试题四：

死锁：

以后开发中应该怎么解决线程安全问题？

守护线程：

定时器：

实现线程的第三种方式：实现Callable接口（JDK8新特性）。

关于Object类中的wait和notify方法（生产者和消费者模式）：

线程间的通信：

线程的状态：

Lock锁：

线程池：

线程池的实现方法：

Java内置线程池的使用：

多线程、并发/并行、自定义线程类、线程安全、守护线程、定时器、线程状态、线程池相关推荐

最新文章

热门文章