Java线程(1)学习笔记

线程(1)学习笔记"/>

Java线程(1)学习笔记

1.什么是线程

线程是计算机能进行运算调度的最小单位，也是程序运行的最小单位。任务调度由时间片论转的调度方式交替运算。

2.线程和进程的区别

（1）线程是程序执行的最小单位，进程是一个计算过程或者是一个任务。

（2）一个进程可以分配多个线程运行。

3.线程的状态

（1）创建状态：当用new操作符创建一个新线程时，这个线程还没开始运行，还处于创建状态。

（2）就绪状态：就绪状态就是可以运行，但还没有开始执行。当调用线程的start()方法，此线程进入就绪状态。当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。

（3）阻塞和等待状态：当线程处于阻塞状态或者等待状态，线程暂时是非活动的，只有当满足某条件下才继续运 行。例如获取一个对象锁的时候没其他线程占用了，就会进入等待状态直到其他线程释放锁。

4.如何创建线程

1.继承Thread类实现

public class TextThread extends Thread {public TextThread(){}public void run(){}//重写run方法
}public static void main(String[] args) {TextThread Thread1=new TextThread();TextThread Thread2=new TextThread();TextThread Thread3=new TextThread();Thread1.start();Thread2.start();Thread3.start();}

2.实现Runnable接口

public class TextRunnable implements Runnable{public void run(){}//重写run方法
public static void main(String[] args) {TextRunnable runnable=new TextRunnable();Thread Thread1=new Thread(runnable,"A");Thread Thread2=new Thread(runnable,"B");Thread Thread3=new Thread(runnable,"B");Thread1.start();Thread2.start();Thread3.start();
}

3.实现Callable接口

与上面两种方式不同，callable可以有返回值。

public class TextCallable implements Callable<String>{@Overridepublic String call(){//实现方法return new String();}
}
public static void main(String[] args) {Callable<String> callable=new TextCallable();FutureTask<String> futureTask1 = new FutureTask<>(callable);FutureTask<String> futureTask2 = new FutureTask<>(callable);  FutureTask<String> futureTask3 = new FutureTask<>(callable);Thread Thread1=new Thread(futureTask1,"A");Thread Thread2=new Thread(futureTask2,"B");Thread Thread3=new Thread(futureTask3,"B");Thread1.start();Thread2.start();Thread3.start();
}

5.守护线程

守护线程的唯一用途就是为其他线程提供服务，例如计时器线程和JVM的垃圾回收器（GC）。当所有非守护线程结束的时候，守护线程也会伴随着自动结束。

Thread daemonThread = new Thread();
//把daemonThread设置为守护线程
daemonThread.setDaemon(true);
//查看该线程是否为守护线程
daemonThread.isDaemon();

6.线程的优先级

​ 每一个线程都有一个优先级。每当线程调用都会优先选择优先级高的线程先运行，但是线程的优先级是高度依赖于系统。

​ 默认情况下线程优先级为5，优先级可以设置为1-10级， 最小为1最大为10。可通过setPriority()设置线程优先级。

Thread thread = new Thread();
thread.setPriority(5);//设置优先级为5

7.Synchronized锁

​ Synchronized关键字 相当于给该方法或者类加上锁，让同一时间内只能有一个线程使用，只有当这个线程使用完释放锁后，下个线程才能获取。

public class TextSyn{int obj;// 对统一对象加锁 public synchronized void run1(){Thread.sleep(1000);//实现对应方法}public synchronized void run2(){//实现对应方法}//对该类加锁public static synchronized void runStatic(){//实现对应方法}public void add(){//同步块 会获取obj的锁，专门用于obj这个对象。synchronized (obj){obj++;}}}
public static void main(String[] args) {TextSyn textSyn1 = new TextSyn();TextSyn textSyn2 = new TextSyn();//会先执行run1,再执行run2;new Thread(()->{textSyn1.run1()}).start();new Thread(()->{textSyn1.run2()}).start();//会先执行run2,再执行run1;new Thread(()->{textSyn1.run1()}).start();new Thread(()->{textSyn2.run2()}).start();//先执行runStatic 后执行run1,是因为run1睡眠了1秒钟，而不是run1先拿到锁//run1的锁是对应这个textSyn对象的，而runStatic是静态方法，对应的是TextSyn这个类的锁//所以他们不属于同一个锁，就不相互影响。new Thread(()->{textSyn1.run1()}).start();new Thread(()->{textSyn1.runStatic()}).start();}

java.lang.Object

void wait();
//将该线程进入等待状态，直到得到通知。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。void notify();
//唤醒该对象上调用了wait()方法的**某一个**线程。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。void notifyAll();
//唤醒该对象上调用了wait()方法的所有线程。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。

8.Lock锁（JUC)

Lock是（java.util.concurrent）下的接口，实现类有

ReentrantLock,
ReentrantReadWriteLock.ReadLock,
ReentrantReadWriteLock.WriteLock

Lock锁的应用

class TextLock{private ReentrantLock lock = new ReentrantLock();public void text(){//加锁lock.lock();try{//业务代码}catch(Exception e){e.printStackTrace();}finally{lock.unlock();//最后一定要解锁，不然会出现死锁问题。}}  
}

java.util.concurrent.locks.Condition

void await();//将该线程放在这个条件的等待集中void singalAll();//唤醒该条件等待集中所有线程void singal();唤醒该条件等待集中某一个线程

公平锁和非公平锁

//公平锁：十分公平：可以先来后到   
new ReentrantLock(true)//非公平锁（默认）：十分不公平：可以插队 
new ReentrantLock(false)

9.Synchronized锁和Lock锁的区别

1、Synchronized 内置的Java关键字， Lock 是一个Java类 。
2、Synchronized无法判断获取锁的状态，Lock 可以判断是否获取到锁。
3、Synchronized 会自动释放锁，Lock必须要手动释放锁[lock.unlock()]，如果不释放锁，会造成死锁。
4、Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
5、Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以判断锁，默认非公平（可以自己设置）；
6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！