进程和线程
进程:进程是程序的一次执行活动,一个进程包含1--n个线程
线程:线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位,是进程中执行运算的最小单位
线程的状态:创建,就绪,执行,阻塞,结束
1 进程的实现方式一 继承Thread
package cjr;
public class ThreadDemo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread my1=new MyThread();
MyThread my2=new MyThread();
my1.start();
my2.start();
}
}
class MyThread extends Thread
{
public void run()
{
for(int i=0;i<5;i++){
try {
Thread.sleep(10);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + " : " +i);
}
}
}
package cjr;
public class ThreadDemo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread my1=new MyThread();
MyThread my2=new MyThread();
my1.start();
my2.start();
}
}
class MyThread extends Thread
{
public void run()
{
for(int i=0;i<5;i++){
try {
Thread.sleep(10);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + " : " +i);
}
}
}
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-1 : 2
Thread-0 : 2
Thread-0 : 3
Thread-1 : 3
Thread-0 : 4
Thread-1 : 4
继承Thread,需修改run()方法,里面填写自己要执行的任务。
当主线程main执行到 new MyThread() ,创建了一个线程,并通过Start() 方法将线程状态更改为就绪状态, 等待CPU调用。 当CPU调用到该线程,会执行run()方法
注:
- 多线程代码执行顺序都是不确定的,因此每次执行的结果都是随机的
- 当线程状态为就绪状态,该线程不能再一次调用start()方法,否则会引发java.lang.IllegalThreadStateException异常
- 若调用my1.run() ,同样会执行MyThread()里的run()方法,但是未开启新的线程,而是main线程执行了run()里的任务。
2 进程的实现方式二 实现Runnable接口
package cjr;
public class ThreadDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyJob job1=new MyJob();
MyJob job2=new MyJob();
Thread t1=new Thread(job1);
Thread t2=new Thread(job2);
t1.start();
t2.start();
}
}
class MyJob implements Runnable
{
@Override
public void run()
{
for(int i=0;i<5;i++){
try {
Thread.sleep(10);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName() + " : " +i);
}
}
}
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-0 : 2
Thread-1 : 2
Thread-0 : 3
Thread-1 : 3
Thread-1 : 4
Thread-0 : 4
- 适合多个相同的程序代码的线程去处理同一个资源
- 可以避免java中的单继承的限制
- 增加程序的健壮性,代码可以被多个线程共享,代码和数据独立
3 线程的状态
2、就绪状态:线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
3、运行状态:就绪状态的线程获取了CPU,执行程序代码。
4、阻塞状态:阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
(一)、等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
(二)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
(三)、其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
5、死亡状态:线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
4 Thread 常用方法及说明
4.1 常用方法
getName() 返回该线程的名称。
getPriority() 返回线程的优先级。
getState() 返回该线程的状态
interrupt() 将线程状态更改为可执行状态, 注:并不一定中断线程(唤醒的线程再次被阻塞的话,线程不会中断)
join() 将线程任务排在当前执行线程之前,暂停当前线程
setName(String name) 改变线程名称
setPriority(int newPriority) 更改线程的优先级。
setDaemon(boolean on) 将该线程标记为守护线程或用户线程,true为守护线程
静态方法
currentThread() 返回对当前正在执行的线程对象的引用
sleep(long millis) 将当前线程从正在执行状态更改为阻塞状态,在millis毫秒后恢复为就绪状态。
yield() 暂停当前正在执行的线程对象,并执行其他线程
4.2 线程类型
4.3 线程优先级
static int MAX_PRIORITY
线程可以具有的最高优先级,取值为10。
static int MIN_PRIORITY
线程可以具有的最低优先级,取值为1。
static int NORM_PRIORITY
分配给线程的默认优先级,取值为5。
5 线程同步
5.1 同步代码块
public class TicketDome {
public static void main(String[] args)
{
Thread.currentThread().setPriority(6);
Ticket ticket=new Ticket();
Thread t1=new Thread(ticket);
Thread t2=new Thread(ticket);
t1.start();
t2.start();
}
}
class Ticket implements Runnable
{
private int num=10;
private Object lock=new Object();
@Override
public void run() {
try {
while(true)
sale();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void sale() throws InterruptedException{
synchronized (lock) {//线程安全代码块
if(num>0){
Thread.sleep(100);
System.out.println("saled by "+ Thread.currentThread().getName()+"; TicketNum--" + num--);
}
}
}
}
输出结果:
saled by Thread-1; TicketNum--9
saled by Thread-1; TicketNum--8
saled by Thread-0; TicketNum--7
saled by Thread-0; TicketNum--6
saled by Thread-0; TicketNum--5
saled by Thread-1; TicketNum--4
saled by Thread-1; TicketNum--3
saled by Thread-1; TicketNum--2
saled by Thread-1; TicketNum--1
注:当使用对象锁时,请确认多个访问的是否是同一个对象锁
5.2 同步方法
如上例中的sale()方法中,所有带代码都是同步代码块, 则可以将同步代码块提炼成同步函数
案例四
public class TicketDome {
public static void main(String[] args)
{
Thread.currentThread().setPriority(6);
Ticket ticket=new Ticket();
Thread t1=new Thread(ticket);
Thread t2=new Thread(ticket);
t1.start();
t2.start();
}
}
class Ticket implements Runnable
{
private int num=10;
private Object lock=new Object();
@Override
public void run() {
try {
while(true)
salesafe();//调用同步方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void sale() throws InterruptedException{
synchronized (lock) {//线程安全代码块
if(num>0){
Thread.sleep(100);
System.out.println("saled by "+ Thread.currentThread().getName()+"; TicketNum--" + num--);
}
}
}
private synchronized void salesafe() throws InterruptedException{//同步函数
if(num>0){
Thread.sleep(100);
System.out.println("saled by "+ Thread.currentThread().getName()+"; TicketNum====" + num--);
}
}
}
saled by Thread-1; TicketNum====9
saled by Thread-1; TicketNum====8
saled by Thread-0; TicketNum====7
saled by Thread-0; TicketNum====6
saled by Thread-0; TicketNum====5
saled by Thread-1; TicketNum====4
saled by Thread-1; TicketNum====3
saled by Thread-1; TicketNum====2
saled by Thread-1; TicketNum====1
注:
- 同步方法使用的对象锁是this对象;
- synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}
- 当synchronized修饰一个static方法时,获取的是类锁(即Class本身,this.getClass(),注意:不是实例);
6 死锁
当同一代码块多个锁对象,在多线程模式下,可能会造成死锁。比如有两把锁A和B,线程1获取了A锁对象等待获取B锁对象访问资源,线程2获取了B锁对象等待获取A锁访问资源,两线程同时在等待,且不释放自身的锁对象,即会引发死锁。
public class DeadLockDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t1=new Thread(new Resource1());
t1.setName("A");
Thread t2=new Thread(new Resource2());
t2.setName("B");
t1.start();
t2.start();
}
}
class Resource1 implements Runnable
{
@Override
public void run() {
while(true){
synchronized (MyLock.lock1) {
System.out.println(Thread.currentThread().getName()+" : --获取lock1,等待lock2");
synchronized (MyLock.lock2) {
System.out.println(Thread.currentThread().getName()+" : --已获取lock2,线程结束");
}
}
}
}
}
class Resource2 implements Runnable
{
@Override
public void run() {
while(true)
{
synchronized (MyLock.lock2) {
System.out.println(Thread.currentThread().getName()+" : --获取lock2,等待lock1");
synchronized (MyLock.lock1) {
System.out.println(Thread.currentThread().getName()+" : --已获取lock1,线程结束");
}
}
}
}
}
class MyLock{
public static Object lock1=new Object();
public static Object lock2=new Object();
}
运行结果:
A : --获取lock1,等待lock2
解决死锁办法:
1)、让所有的线程按照同样的顺序获得一组锁。这种方法消除了 A 和 B 的拥有者分别等待对方的资源的问题。
2)、将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中,可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
3)、将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时,就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是,它就可以获得相关的锁,否则,就要释放掉银器这个锁并稍后再尝试。
7 线程等待wait() notify() notifyAll()
这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。
如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去,然后处于等待状态。
如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行
Obj.wait(),与Obj.notify()必须要与synchronized(Obj)一起使用,也就是wait,与notify是针对已经获取了Obj锁进行操作
public class ThreadWaitDome {
public static void main(String[] args)
{
Resource resource=new Resource();
Input input=new Input(resource);
Output output=new Output(resource);
Thread t0=new Thread(input);
Thread t1=new Thread(output);
t0.start();
t1.start();
}
}
class Resource
{
private String name;
private String address;
private boolean canRead=false;
public synchronized void set(String name,String address) throws InterruptedException
{
if(canRead)
wait();
this.name=name;
this.address=address;
this.canRead=true;
notify();
}
public synchronized void read() throws InterruptedException
{
if(!canRead)
wait();
System.out.println(Thread.currentThread().getName()+" : "+name+" ======== " +address );
this.canRead=false;
notifyAll();
}
}
class Input implements Runnable
{
private Resource resource;
public Input(Resource res){
this.resource=res;
}
@Override
public void run() {
int i=0;
while(true)
{
if(i==0)
try {resource.set("陈佳仁", "杭州滨江");} catch(InterruptedException e){}
else
try {resource.set("cjr", "HangZhou");} catch(InterruptedException e){}
i=(i+1)%2;
}
}
}
class Output implements Runnable
{
private Resource resource;
public Output(Resource res){
this.resource=res;
}
@Override
public void run() {
while(true)
try {this.resource.read();} catch(InterruptedException e){}
}
}
Thread-1 : cjr ======== HangZhou
Thread-1 : 陈佳仁 ======== 杭州滨江
Thread-1 : cjr ======== HangZhou
Thread-1 : 陈佳仁 ======== 杭州滨江
Thread-1 : cjr ======== HangZhou
共同点:
1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛出InterruptedException。
不同点:
1. sleep,yield()是Thread类的方法
wait(),notify(),notifyAll() 是Object的方法
3. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互,来实现线程的同步。
sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。
4. wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
5. sleep,wait必须捕获异常,notify和notifyAll不需要捕获异常
所以sleep()和wait()方法的最大区别是:
sleep()睡眠时,保持对象锁,仍然占有该锁;
而wait()睡眠时,释放对象锁。
8 Lock Condition 锁 监视器
Condition的功能类似在传统线程技术中的Object.wait()和Object.natify()的功能,传统线程技术实现的互斥只能一个线程单独干,不能说这个线程干完了通知另一个线程来干,Condition就是解决这个问题的,实现线程间的通信。public class ThreadWaitDome {
public static void main(String[] args)
{
Resource resource=new Resource();
Input input=new Input(resource);
Output output=new Output(resource);
Thread t0=new Thread(input);
Thread t1=new Thread(output);
t0.start();
t1.start();
}
}
class Resource
{
private String name;
private String address;
private boolean canRead=false;
private Lock lock = new ReentrantLock(); // 锁
private Condition readCondition = lock.newCondition(); // 读取条件
private Condition setCondition = lock.newCondition(); // 写入条件
public void set(String name,String address) throws InterruptedException
{
lock.lock();
if(canRead)
setCondition.await();
this.name=name;
this.address=address;
this.canRead=true;
readCondition.signal();
lock.unlock();
}
public void read() throws InterruptedException
{
lock.lock();
if(!canRead)
readCondition.await();
System.out.println(Thread.currentThread().getName()+" : "+name+" ======== " +address );
this.canRead=false;
setCondition.signal();
lock.unlock();
}
}
class Input implements Runnable
{
private Resource resource;
public Input(Resource res){
this.resource=res;
}
@Override
public void run() {
int i=0;
while(true)
{
if(i==0)
try {resource.set("陈佳仁", "杭州滨江");} catch(InterruptedException e){}
else
try {resource.set("cjr", "HangZhou");} catch(InterruptedException e){}
i=(i+1)%2;
}
}
}
class Output implements Runnable
{
private Resource resource;
public Output(Resource res){
this.resource=res;
}
@Override
public void run() {
while(true)
try {this.resource.read();} catch(InterruptedException e){}
}
}