多线程是多个线程同时对同一个数据执行相同或不同的任务。要注意的是，这样的操作很大可能会出现线程安全问题，和线程死锁问题。
现介绍一下为什么要用同步线程：
public class MyThread implements Runnable {
private int ticket=10;
@Override
public void run() {
for(int i=0;i<10;i++){
if(this.ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
}
}
}
}
单多个线程访问同一个对象是，会出现其中一条线程执行业务代码的时候，CPU的执行权被另一条线程抢走了，通过上面代码可以明显看出输出了负数，这和我们现实生活是完全不存在的。这就是线程安全问题
这使得我们需要通过静态化ticket，或者是用同步线程来实现我们要的功能。
下面先介绍一下怎么解决线程安全问题的实现；
方式一：可以使用同步代码块来实现。
示例：
public class MyThread implements Runnable {
private int ticket=10;
@Override
public synchronized void run() {
for(int i=0;i<10;i++){
if(this.ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
}
}
}
}
示例二：使用同步代码块来实现
public class MyThread implements Runnable {
private int ticket=10;
@Override
public void run() {
for(int i=0;i<10;i++){
synchronized ("锁"){
if(this.ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
}
}
}
}
}
上面两种方式都能实现代码的同步，
线程之所以能同步，是因为加了一个锁对象，在使用同步函数的时候，锁对象是对象本身this，而在使用同步代码块的时候，锁对象是自己定义的，可以是任何对象。
建议：要是用同步线程的时候，建议优先使用同步代码块，因为同步代码块锁对象是自己定义的，方便对锁进行操作。这个原因下面将要说到。
通过上面的代码会发现，我在方法中使用了sleep方法。sleep（）方法是Thread类中的一个方法，为什么没有把它放到上一节将，是因为这个方法有点特殊。这个涉及到线程的各种状态：
线程开始的时候是创建状态：（new 对象的时候.）
当调用了start方法的时候，线程处于可以运行状态，在这个状态下的线程具备CPU的等待权，但是不具备CPU的执行权。
当线程执行的时候他具备了CPU的执行权。这个时候称为运行状态。
当完成任务代码块的时候，线程死亡。
在可运行状态和运行状态之间还有一个状态，这个状态称为临时阻塞状态。进入这个状态需要调用sleep()或wait()方法。这个时候线程不具备CPU的等待资格，和CPU的执行权。
sleep()方法是自己设置阻塞时间。当时间一到，线程会自动转换成可运行状态。他是Thread中的一个方法。当一个线程在同步方法中调用了sleep方法，其它线程不能调用它的其它同步方法。
swit()是Object中的一个方法，当线程调用了这个方法。需要通过notify或者notifyAll方法来唤醒线程。线程阻塞是存放在线程池中的。一个对象对应一个线程池。
当线程阻塞是，线程会自动释放CPU的等待权和CPU的执行权。但是如果使用的sleep方法，线程是不会释放锁对象的。而wait方法是会释放锁对象。
下面说下经典的线程通讯：
//产品类
class Product{
String name; //名字
double price; //价格
boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
}
//生产者
class Producer extends Thread{
Product p ; //产品
public Producer(Product p) {
this.p = p ;
}
@Override
public void run() {
int i = 0 ;
while(true){
synchronized (p) {
if(p.flag==false){
if(i%2==0){
p.name = "苹果";
p.price = 6.5;
}else{
p.name="香蕉";
p.price = 2.0;
}
System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
p.flag = true;
i++;
p.notifyAll(); //唤醒消费者去消费
}else{
//已经生产 完毕，等待消费者先去消费
try {
p.wait(); //生产者等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
//消费者
class Customer extends Thread{
Product p;
public Customer(Product p) {
this.p = p;
}
@Override
public void run() {
while(true){
synchronized (p) {
if(p.flag==true){ //产品已经生产完毕
System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
p.flag = false;
p.notifyAll(); // 唤醒生产者去生产
}else{
//产品还没有生产,应该 等待生产者先生产。
try {
p.wait(); //消费者也等待了...
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class Demo5 {
public static void main(String[] args) {
Product p = new Product(); //产品
//创建生产对象
Producer producer = new Producer(p);
//创建消费者
Customer customer = new Customer(p);
//调用start方法开启线程
producer.start();
customer.start();
}
}
线程死锁的体现：
lass DeadLock extends Thread{
public DeadLock(String name){
super(name);
}
public void run() {
if("张三".equals(Thread.currentThread().getName())){
synchronized ("遥控器") {
System.out.println("张三拿到了遥控器，准备 去拿电池!!");
synchronized ("电池") {
System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}else if("狗娃".equals(Thread.currentThread().getName())){
synchronized ("电池") {
System.out.println("狗娃拿到了电池，准备去拿遥控器!!");
synchronized ("遥控器") {
System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}
}
}
public class Demo2 {
public static void main(String[] args) {
DeadLock thread1 = new DeadLock("张三");
DeadLock thread2 = new DeadLock("狗娃");
//开启线程
thread1.start();
thread2.start();
}
}
死锁现象出现 的根本原因：
- 存在两个或者两个以上的线程。
- 存在两个或者两个以上的共享资源。
【注】讲解可能有不足的地方，希望各位小伙伴能帮我补充不足之处，谢谢！
复制得来终觉浅，要想知道自己敲！