一,进程、线程和多线程
- 进程:正在进行中的程序(直译)。
- 线程:进程中一个负责程序执行的控制单元(执行路径)。
- 多线程:一个进程中可以有多个执行路径,称之为多线程。
- 好处:解决了多部分代码同时运行的问题。
- 弊端:线程太多,会导致效率的降低。
二、创建进程方式
1. 方式一:继承Thread类
- 步骤:
- 定义一个类继承Thread类。
- 覆盖Thread类中的run方法。
- 直接创建Thread的子类对象创建线程。
- 调用start方法开启线程并调用线程的任务run方法执行。
构造方法:
- Thread(Runnable target)分配新的 Thread 对象,target为其run 方法被调用的对象。
继承自Object的方法
- void wait( ) / void wait(long timeout) 让线程处于冻结状态,被wait的线程会被存储到线程池中。
- void notify( ) 唤醒线程池中的一个线程(任何一个都有可能)。
- void notifyAll( ) 唤醒线程池中的所有线程。
注意:该三种方法只能由锁来调用
常用方法
- static Thread currentThread( ) 返回对当前正在执行的线程对象的引用
- long getId( ) 返回该线程的标识符。
- void setName( String name )改变线程名称,使之与参数 name 相同。
- String getName( ) 返回该线程的名称。
- void setPriority( int newPriority ) 更改线程的优先级。
- int getPriority( ) 返回线程的优先级。
- Thread.State getState( ) 返回该线程的状态。
线程状态(6中): NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED已
- String toString( ) 返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
- void run( ) 如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
static void sleep( long millis ) 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。
- wait和sleep区别
- wait可以指定时间也可以不指定。sleep必须指定时间
- 在同步中,对CPU的执行权和锁的处理不同
- wait:释放执行权,释放锁
- sleep:释放执行权,不释放锁
- wait和sleep区别
void start( ) 使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
- void join( ) 等待该线程终止(当A线程执行到B线程的.join()方法时,等B线程都执行完,A才会执行)。注:临时加入一个线程可以使用该方法。
- static void yield( ) 暂停当前正在执行的线程对象,并执行其他线程。
- void setDaemon( boolean on ) 将该线程标记为守护线程或用户线程。
2.方式二:实现 Runnable 接口(常用方式:避免了Java单继承的局限性)
- 步骤:
- 定义类实现Runnable接口。
- 覆盖接口中的run方法,将线程的任务代码封装到run方法中。
- 通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递(因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务)。
- 调用线程对象的start方法开启线程。
三,线程安全问题
1. 产生原因:
- 多个线程在操作共享数据
- 操作共享数据的线程代码有多条
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,就导致线程安全问题的产生。
2. 解决办法
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
同步代码块
- 格式:
synchronized(obj)
{
//obj是一个对象,表示锁(监视器锁)
//持有锁的线程可以在同步中执行,没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
}
同步方法(函数)
- 格式:在方法上加上synchronized修饰符即可。(一般不直接在run方法上添加)
同步方法的同步监听器其实是 this
synchronized 返回值类型 方法名(参数列表)
{
}
- 同步函数和同步代码块的区别
- 同步函数的锁是固定的this
- 同步代码块的锁是任意的对象
建议使用同步代码块
注意:
- 如果同步函数和同步代码块都使用this作为锁,就可以实现同步
- 静态同步函数的锁是该函数所属字节码文件对象,可以getClass方法获取,也可以用当前类名.class表示。
死锁:
常见情形为同步的嵌套,当两个线程相互等待对方释放同步监视器时就会发生死锁。一旦出现死锁,程序既不会发生任何异常,也不会出现任何提示。
同步锁
JDK 1.5以后的另一种同步机制,将同步和锁封装成对象
Lock接口(位于java.util.concurrent.locks包):替代了同步代码块或者同步函数
- 子类:ReentrantLock
- 方法摘要:
- Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例,以调用其方法。
- void lock( ) 获取锁
- void unlock( ) 释放锁 ,为了防止异常出现,导致锁无法被关闭,所以锁的关闭动作要放在fianlly中
Condition接口(位于java.util.concurrent.locks包):
- 替代了Object中的wait、notify和notifyAll方法,分别为:await、signal和signalAll方法。
四,线程间通信
1. 使用时机
- 多个线程在处理同一资源,但是任务却不同,这时就需要线程间通信。
2. 等待/唤醒机制方法
wait、notify和notifyAll都定义在Object类中,因为这些方法都是监视器(锁)的方法,锁可以是任意的对象,任意的对象调用方式一定在Object类中。
- 生产者消费者示例(生产一个,消费一个):
//该示例中,实现了本方只唤醒对方的操作
import java.util.concurrent.locks.*;
class ProducerConsumerDemo {
public static void main(String[] args) {
Resource r=new Resource();
//通过已有的锁获取两组监视器,一组监视生产者,一组监视消费者
Producer pro=new Producer(r);
Consumer con=new Consumer(r);
Thread t1=new Thread(pro);
Thread t2=new Thread(con);
Thread t3=new Thread(pro);
Thread t4=new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource {
private String name;
private int count=1;
private boolean flag=false;
private Lock lock=new ReentrantLock();
private Condition condition_pro =lock.newCondition();
private Condition condition_con =lock.newCondition();
public void set(String name)throws InterruptedException {
//加锁
lock.lock();
try {
while(flag)
condition_pro.await(); //生产方线程被存储到线程池中
this.name=name+"..."+count++;
System.out.println(Thread.currentThread().getName()+".....生产者....."+this.name);
flag=true;
condition_con.signal(); //唤醒处于线程池中的消费方线程
}
// 使用finally块保证释放锁
finally{
lock.unlock();
}
}
public void out()throws InterruptedException {
//加锁
lock.lock();
try {
while(!flag)
condition_con.await(); //消费方线程被存储到线程池中
System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
flag=false;
condition_pro.signal(); //唤醒处于线程池中的生产方线程
}
// 使用finally块保证释放锁
finally {
lock.unlock();
}
}
}
//定义生产者类,实现Runnable接口,覆盖run方法
class Producer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res=res;
}
public void run(){
while (true) {
try {
res.set("+商品+");
}
catch (InterruptedException e) {
}
}
}
}
//定义消费者类,实现Runnable接口,覆盖run方法
class Consumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res=res;
}
public void run() {
while (true) {
try {
res.out();
}
catch (InterruptedException e) {
}
}
}
}
3. 停止线程
- 思路:
- 任务中通常都有循环结构,只要控制循环就可以结束任务
- 控制循环通常用定义标记来完成
- 如果线程处于冻结状态,无法读取标记,可以使用interrupt()方法将线程从冻结状态强行恢复到运行状态,让线程具备CPU执行权,该动作会发生InterruptedException,需要处理