线程与同步

我的Java进阶旅程之 线程、同步

主要内容

• 线程
• 同步
• 线程状态

学习目标

• 能够描述多线程的运行原理

• 能够使用继承类的方法创建多线程

• 能够使用接口类的方法创建多线程

• 对比继承类和接口类实现多线程的优劣

• 理解线程安全问题出现的原因

• 使用同步代码块解决线程安全问题

• 使用同步方法解决线程安全问题

• 记住线程状态

第一章 线程

1、运行原理

2、Thread类

Thread的构造方法：

public Thread(): 分配一个新线程对象
public Thread(String name):分配一个新线程对象，并指定名字
public Thread(Runable target):分配一个新线程对象，带有指定目标
public Thread(Runable target,String name):分配一个新线程对象，指定目标以及名称

Thread中的常用方法：

public String getName():获得当前线程的名称
public void start();开始执行线程；Java调用此线程的run方法
public void run():
public static void sleep(long millis):正在执行的线程暂停   ms
public static Thread currentThread():返回正在执行的线程对象

3、Runable方法创建线程

1、实现Runable方法对象，创建线程执行对象

2、将实现的方法对象在Thread中运行

public class MyThread extends Thread{
/*    
 * 利用继承中的特点     
 *   将线程名称传递  进行设置    
 */    
public MyThread(String name){    
super(name);        
}    
/*    
 * 重写run方法    
 *  定义线程要执行的代码    
 */    
public void run(){          
for (int i = 0; i < 20; i++) {
//getName()方法 来自父亲            
System.out.println(getName()+i);            
          }        
     }    
}

public class Demo {
    public static void main(String[] args) {
           System.out.println("这里是main线程");  
           MyThread mt = new MyThread("小强");           
           mt.start();//开启了一个新的线程    
           for (int i = 0; i < 20; i++) {    
           System.out.println("旺财:"+i);            
           }        
       }    
}

4、Thread类的实现多线程方法

1、继承Thread类，创建线程，重写run方法

2、新建并执行已经创建的类

public class MyRunnable implements Runnable{
@Override    
public void run() {    
for (int i = 0; i < 20; i++) {        
System.out.println(Thread.currentThread().getName()+" "+i);            
           }        
     }    
}

public class Demo {
    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable mr = new MyRunnable();
        //创建线程对象
        Thread t = new Thread(mr, "小强");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财 " + i);
        }
    }
}

5、两种方法的对比

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

第二章 线程安全

线程安全

原因：共享数据访问未保护

线程同步

Java中提供了同步机制（synchronized）来解决

• 同步代码块。

synchronized(同步锁){
        需要进行同步操作的代码  
}

• 同步方法。

  使用synchronized修饰的方法，就叫做同步方法。保证某一线程正在执行该方法时，其他线性不能执行该方法。

  public synchronized void method(){
    会产生安全问题的代码
    就是上面需要同步操作的代码
  }
  

  与上面同步代码块相似，会存在同步锁：

  对于静态方法，我们使用当前方法所在类的字节码对象（类名.class）

  对于非静态方法，同步锁就是this

与同步代码块相比较，同步方法将同步对象方法化，便于调用，增加了同步对象的灵活性。

• 锁机制

public void lock();

public void unlock();

使用时首先创建Lock lock = new ReentrantLock();

疑问：1、ReentrantLock（）是什么对象？

2、run方法中存在多个需要保证同步的代码块怎么处理？

第三章 线程状态

线程状态概述

从线程被创建到被释放的生命周期中，线程一直处在不同的状态下。

线程状态	状态产生的条件
new（）：新建线程	被创建，未启动。未调用start方法
Runnable（）:可运行
Blocked：阻塞	未拿到锁对象
Waiting：无限等待	等待另一个线程用notify或notifyAll唤醒自己
Timed Waiting：计时等待	要么被唤醒，要么计时超时
Teminated：终止

Timed Waiting(计时等待)

参考案例：Thread.sleep()就是计时等待，在休眠期间线程被挂起。

为了只挂起自己的线程，应该讲Thread.sleep放在线程内部执行

Bloched（阻塞线程）

眠期间线程被挂起。

为了只挂起自己的线程，应该讲Thread.sleep放在线程内部执行

[外链图片转存中…(img-cWcym3ei-1604144928828)]
##全部状态

##线程之间通信