进程与线程
进程:进程是计算机中程序关于某次数据集合上的一次运行活动,是体统进行分配和资源调度的基本单位,是操作系统的基础,进程是线程的容器。当然进程也可以创建多个线程。
自我理解:进程是一种容器,比如在一个房间里,有爸爸妈妈我三个线程,当爸爸在家的时候,他想干什么就干什么(有地位的话),但是我和爸爸在家的话,我看动画片,爸爸就不能看体育,也就是两个线程争夺资源,当然大部分的时候三个线程相互协作,我写作业,爸爸挣钱养家,妈妈做家务。保证了进程的整体的安全。
线程的状态
线程的所以状态在Thread中的State是枚举定义的
public enum State{
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
初始线程
第一种方法:
Thread thread = new Thread();
thread.start();
线程在调用了start方法之后,start就会新建一个线程放这个线程执行run方法,但是若调用的run方法的话,那么只会在当前线程中串行的执行run()中的代码,同时run方法是需要我们自己重写的,不然他什么都干不了
第二种方法:
public class CreateThread implements Runnable{
public static void mian(String[] args){
Thread thread = new Thread(new CreateThread());
thread.start();
}
}
实现Runnable接口,并且将实例传入Thread,这样可以避免重载run方法。
第三种:
实现实现Callable接口重写call方法
第四章:
线程池创建
终止线程
线程一般运行完就会自动关闭,但是有时候一些服务端的线程可能会常驻系统,这时候可以用Thread的stop去关闭,但是stop是暴力关闭(并且释放改对象所持有的锁),比如某个线程执行到一半就强行关闭,那么可能导致数据不一致的,所以当我们想要关闭一个线程的时候,我们自行决定线程何时退出就行。
线程中断
线程中断并不会让线程立马退出,而是给线程发送一个通知,告知目标线程,希望你退出,是否退出完全由线程自己去处理,若中断后,线程无条件退出,那就和直接调用stop方法一样,会产生很多的问题。
public void Thread.interrupt();//中断线程
public boolean Thread.isInterrupt();//判断是否被中断
public static boolean Thread.interrupted();//判断是否被中断,并且清除当前的中断状态
下面的代码就进行的中断操作,如果没有if判断,那么虽然给了thread进行了中断,但是thread并没有处理中断的逻辑,所以thread线程也仅仅是被置于中断状态,但是这个中断没有任何作用。
加了if了的话,可以判断当前线程是不是处于中断状态,如果是,那么退出while循环,结束线程。一般出现wait()和sleep()这样的操作,只能同中断来识别。
public class interruptThread {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(){
public void run(){
while(true){
if(Thread.currentThread().isInterrupted()){
System.out.println("interrupt");
break;
}
Thread.yield();
}
}
};
thread.start();
Thread.sleep(1000);
thread.interrupt();
}
}
线程wait()/等待和notify()/通知
这两个是Obejct类中的方法,也就是说什么对象都可以调用这两个方法。
public final void wait() throws InterruptedException
public final native void notify()
当一个对象实例被调用了wait的方法后,当前线程就会这个对象等待,比如:线程A调用了obj.wait()方法,那么线程A就停止执行,转为等待状态,当线程A等到其他的线程出现调用obj.notify()方法为止,这个时候,obj对象就成为多个线程的通信手段。
notify()方法是从等待队列中随机唤醒一个线程,完全随机选择。但是notifyAll()方法就是把等待队列的所以线程都唤醒。
此外Object.wait()方法必须在对应的synchronized语句中。
public class PublicThreadWN {
final static Object obj = new Object();
public static class T1 extends Thread{
public void run(){
synchronized(obj){
System.out.println(System.currentTimeMillis()+":T1 start!");
try{
System.out.println(System.currentTimeMillis()+"T1 wait for obj");
obj.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(System.currentTimeMillis()+":T1 is end");
}
}
}
public static class T2 extends Thread{
public void run(){
synchronized(obj){
System.out.println(System.currentTimeMillis()+":T2 is start");
obj.notify();
System.out.println(System.currentTimeMillis()+":T2 end");
try{
Thread.sleep(2000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
Thread t1 = new T1();
Thread t2 = new T2();
t1.start();
t2.start();
}
}
输出结果为:
1506662910562:T1 start!
1506662910562T1 wait for obj
1506662910562:T2 is start
1506662910562:T2 end
1506662912562:T1 is end
为什么会这样呢,开启了两个线程T1和T2,T1执行了wait方法,在T1执行这个方法前,先获取了obj的对象锁,wait执行完,T1开始等待,同时释放obj的锁,T2在执行notify()方法前,也会先获得obj对象锁,之后T1在得到notify()的通知后,还是会先尝试着重写获得obj的对象锁,可以看见在T2执行完之后2秒后,T1才执行end。
wait和sleep的区别?
Object.wait和Thread.sleep方法都可以让程序等待若干时间,但是wait可以被唤醒,而且wait会释放目标对象的锁,但是Thread.sleep()缺少不会释放目标对象的锁。
sleep之所以被try-catch包裹是因为如果程序在sleep方法执行后,当前线程会休眠一段时间,会抛出InterruptedException,它不是一个运行时异常,所以必须得处理。
线程的挂起(suspend)和继续执行(resume)
suspend和resume是两个看起来很有用的方法,但是不推荐使用,而且已经作废的方法,suspend()在导致线程暂停的时候,并不会让线程释放任何锁资源,所以,其他的线程想要访问它被它占用的方法锁时,都会被牵连,导致无法正常运转。知道在对应的线程上运行了resume()操作,被挂起的线程才能继续,从而所有相关锁上的线程也可以继续执行,但是resume()操作意外的在suspend()之前执行了,那么挂起的线程就很难有机会被继续执行,而且占用的锁也得不到释放了,导致整个系统工作不正常,同时被挂起的线程,从状态上来看,居然是Runnable。
等待线程结束(join)和谦让(yield)
public final void join() throws InterruptedException
public final synchronized void join(long mills) throws InterrupredException
第一个join表示无线等待,一直阻塞当前线程,直到目标线程执行完毕。
第二个join方法给了一个最大的等待时间,如果超过时间线程还在运行,当前线程就会因为等不及而继续向下开始执行。
join方法的作用是,调用join方法的线程先执行完,其他线程再操作,也就是变并行为串行。
Thread.yield();
public static void yield();
改方法一单执行,那么就会让当前线程让出CPU,让出CPU不表示当前线程不执行了,当前线程再让出CPU之后,还会进行CPU资源抢夺,但是能否够再次被分配到,就不一定了。
理解起来也就是,Thread.yield的 调用完成了自己的一些工作,他就可以休息一下,给其他一些线程一些工作机会。一般用于优先级非常低和不重要的线程,减少CPU占用资源。
volatile
volatile的作用就是保持这个变量的可见性。最新值。易修改的
volatile可以保证数据的可见性和有序性。
volatile不能代替锁的一个原因就是,volatile对复合操作的原子性无法保证,比如i++
守护线程
守护线程是一种特殊的线程,系统的守护者,在后台默默地完成一些系统性的服务,比如垃圾回收线程,当一个java应用只有守护线程的时候,java虚拟机就自动退出了。
设置守护线程需要在start()之前设置,不然会出现异常(可以正常执行,但是该线程会被当做用户线程去执行)
线程优先级
java线程优先级有1到10个等级,内部有三个内置静态标量表示
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public fianl static int MAX_PRIORITY = 10;
数字越大,优先级越高,高优先级的一般比低优先级的完成的更快。
synchronized
指定加锁的对象:对对象加锁,进入同步代码块前要获得给定对象的锁。
直接作用于实例方法:相当于对当前实例加锁,进入同步代码前要获得当前实例的锁。
直接作用于静态方法:相当于当当前类加锁,进入同步代码前要获得当前类的锁。