1.线程的状态:
新建:线程被创建出来
就绪:线程具有执行资格,没有执行权。
运行:线程具有执行资格,具有执行权。
阻塞:线程不具有执行资格,也不具有执行权。
死亡:线程不具有执行资格,也不具有执行权,线程死亡了,等待回收。
2.线程池
为什么要出现线程池:
线程是CPU执行的基本单位,我们每次开启一个线程是很浪费资源的。而线程池是一个可以帮我们预先创建线程对象的地方,创建好放在池子中,等有任务需要执行了,我们就可以让线程池中的线程去执行,任务执行完线程池中的线程还可以回收,下次还可以用来执行任务。
(1)线程池:是一个容器,装有线程对象的容器,可以帮我们管理线程对象;
线程池可以预先帮助我们创建一些数量的线程对象,放在池子中,等人为需要执行了,就可以让线程去执行任务,执行完了,可以回收 。
(2)线程池原理:
如何获取线程池:JDK1.5之前需要我们自己去动手实现,1.5之后java给我们内置好了线程池,直接使用即可。
线程池工厂:Executors工厂类来生产线程池。
(3)Executors工厂类生产线程的方法:
public static ExecutorService newCachedThreadPool();根据任务的数量来创建线程的个数。
public static ExecutorService newFixedThreadPool(int nThread);固定初始化几个线程
public static ExecutorService newSingleThreadExector();初始化一个线程的线程池;单线程工作,一次只能执行一个任务。
以上的方法返回的都是ExecutorService对象,该对象表示一个线程池,可以执行Runnable或者Callable对象代表的线程。
Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且无法抛出经过检查的异常。
Callable 这个任务接口,执行完之后会有返回值 跟线程池配合使用,Callable中要重写call方法。
Runnable 这个任务接口 执行完之后没有返回值
使用步骤: (1).创建线程池对象;(2).创建Runnable实例;(3).提交Runable实例;(4).关闭线程池shutdown()方法。
(4)ExecutorService中的方法:
Future<?>submit(Runnable task);提交一个Runnable任务用于执行。并返回一个表示该任务的Future。
Futuresubmit(Runnable task,T result);提交一个Runnable任务用于执行。并返回一个表示该任务的Future。
Futuresubmit(Callabletask);提交一个返回值的任务用于执行,返回一个表示任务的未决结果的Future。
接口Future表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成。计算完成后只能使用get方法获取结果。
代码如下:
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-----"+"任务执行了");
}
}
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
@Override
public String call() {
String s="程序执行了";
System.out.println(Thread.currentThread().getName()+"----"+s);
return s;
}
}
public class MyRunnableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建一个单线程对象的线程池
ExecutorService service = Executors.newSingleThreadExecutor();
//提交Runnable实例
MyRunnable myRunnable = new MyRunnable();
Future submit=service.submit(myRunnable );
System.out.println(submit.get());//没有返回值null
Future<Integer> submit1=service.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=1;i<=100;i++){
sum+=i;
}
return sum;
}
});
System.out.println(submit1.get());//返回值5050
service.shutdown();
}
}
public class MyRunnableTest2 {
public static void main(String[] args) {
//根据任务的数量创建线程
ExecutorService service= Executors.newCachedThreadPool();
MyRunnable myRunnable = new MyRunnable();
Future submit=service.submit(myRunnable);
Future submit1=service.submit(myRunnable);
Future submit2=service.submit(myRunnable);
Future submit3=service.submit(myRunnable);
service.shutdown();
}
}
public class MyCallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//定义有三个线程的线程池
ExecutorService service= Executors.newFixedThreadPool(3);
MyCallable myCallable=new MyCallable();
Future<String> submit=service.submit(myCallable);
Future<String> submit1=service.submit(myCallable);
Future<String> submit2=service.submit(myCallable);
System.out.println(submit.get());
System.out.println(submit1.get());
System.out.println(submit2.get());
service.shutdown();//关闭线程池
}
}
3.用匿名内部类开起线程。
匿名内部类:本质相当于一个对象,是实现了该接口或继承了该抽象类的子类对象。
匿名内部类的方式实现多线程程序:new Thread(){代码…}.start();
New Thread(new Runable(){代码…}).start();
代码如下:
public class MyTest {
public static void main(String[] args) {
new Thread(new Thread(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"程序执行了");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类开启线程");
}
}).start();
}
}
4.定时器:一个工具类,在指定的时间或日期执行任务。
定时器是一个应用十分广泛的线程工具,可以用于调度多个定时任务以后台线程的方式运行。
可以通过Timer和TimerTask类来实现定义调度的功能。
(1)Timer一种工具,线程用其安排以后在后台线程中执行的任务,可以安排任务执行一次或者重复执行。
public Timer();默认的构造方法
public void schedule(TimerTask task, long delay);
延迟delay秒之后执行
public void schedule(TimerTask task, long delay, long period);
第一次延时delay秒之后执行,以后每间隔period执行。
public void schedule(TimerTask task, Date time);
在指定日期执行
public void schedule(TimerTask task, Date firstTime, long period)
在指定日期第一次执行,然后间隔period秒重复执行。
(2)TimerTask 定时任务
TimerTask()创建一个新的计时器任务。
public abstract void run()计时器任务要执行
public Boolean cancel()取消执行任务。
代码如下:
public class MyTimerTest1 {
public static void main(String[] args) {
Timer timer=new Timer();
TimerTask timerTask=new MyTimerTask(timer);
// timer.schedule(timerTask,1000);//延迟1秒后执行任务
timer.schedule(timerTask,2000,1000);//延迟2秒后执行,然后间1秒,重复执行
}
}
public class MyTimerTest2 {
public static void main(String[] args) throws ParseException {
//在指定日期执行
String str="2018-11-21 22:09:30";
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date=simpleDateFormat.parse(str);
Timer timer=new Timer();
MyTimerTask myTimerTask = new MyTimerTask(timer);
timer.schedule(myTimerTask,date);
}
}
//定时任务
public class MyTimerTask extends TimerTask {
//定时器
Timer timer;
public MyTimerTask(Timer timer){
this.timer=timer;
}
@Override
public void run() {
//System.out.println("定时任务执行了");
//定时关机
Runtime runtime=Runtime.getRuntime();
try {
runtime.exec("shutdown -s -t 0");
} catch (IOException e) {
e.printStackTrace();
}
}
}
案例:定时删除多级文件夹目录
public class Demo {
public static void main(String[] args) {
//定时删除指定的带内容的目录
Timer timer=new Timer();
MyTimerTask1 timerTask=new MyTimerTask1(timer);
timer.schedule(timerTask,3000);
}
}
public class MyTimerTask1 extends TimerTask {
Timer timer;
public MyTimerTask1(Timer timer){
this.timer=timer;
}
@Override
public void run() {
File file=new File("D:\\course");
deleteFile(file);
}
private void deleteFile(File file) {
File[] files = file.listFiles();
for (File f : files) {
if (f.isFile()) {
f.delete();
}else{
deleteFile(f);
}
}
file.delete();
}
}
5.(1)Java内存模型
Java 内存模型规定了所有变量都存储在主内存中,每一条线程还有自己的工作内存。线程的工作内存 中存储了被该线程所使用的变量(该变量是从主内存中拷贝过来的)。
线程对变量的操作(读取,赋值)都必须在内存中进行;但是不同线程之间是不能通信的,即无法访问对方工作内存中的变量,线程间变量值的传递均需要通过主内存来完成。
(2)Java中的可见性
在java中提供了Volatile关键字来保证可见性。
普通的共享变量不能保证可见性,因为普通变量被修改之后,什么时候把值写入到主内存是不确定的,所以当其他线程读取时,此时内存中有可能还是其他的旧值,因此无法保证可见性。
但是当volatile修饰之后的共享变量,它能保证被修改后的值会立即被更新的主内存,当有其他线程来读取时,读取到的就是新的值,所以保证了java 的可见性。
(3)Volatile关键字,当多个线程共享数据时,能够保证内存之间的可见性。相当于比synchronize较轻量级的同步策略。
但是注意Volatile不能保证原子性,不具备互斥性。
代码如下:
public class DemoTest {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
while(true){
if(myRunnable.isB()){
System.out.println("程序进来了,值修改成功");
break;
}
}
}
}
public class MyRunnable implements Runnable {
private volatile boolean b=false;
public void setB(boolean b){
this.b=b;
}
public boolean isB(){
return b;
}
@Override
public void run() {
//线程睡3秒
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
b=true;
System.out.println("b的值更改了"+b);
}
}
6.CAS算法
(1).什么是CAS算法:
CAS的是Compare and Swap的简称,即比较再交换。
Jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronize同步锁的乐观锁。JDK5之前是依靠syncthronize关键字保证同步的,这是一种独占锁,也是悲观锁。
CAS是一种硬件对并发的支持,针对多处理器操作而设计的一种特殊指令,用于管理对共享数据的并发访问。
(2)CAS的算法过程描述:
CAS算法是一种无锁的算法,内存值V,旧的预期值A,要修改的新值B。当且仅当A与V相同时,将V值修改为新值B,否则什么都不做。
例子:
在上图中,线程1 与线程2同时抢时间片,假设线程1先抢到(注意:一个线程抢到另一个没抢到,则没抢到的那个线程并不挂起,下次继续参与抢。),先执行,线程1中就得预期值A是10,内存值V是10,两者一样,进行值修改加一,得到新值B为11,写入内存内存值V变为11,同时线程2的旧的预期值为10,和内存值V的值11不一样,则不进行任何操作。两个线程再次进行抢时间片,继续下轮执行。
(3)CAS算法在JDk中的应用
在原子类变量中,例如java.util.concurrent.atomic中的原子操作类AtomicXXX
都使用了这些底层的JVM支持为数字类型的引用类型提供了一种高效的CAS操作。
而在java.util.concurrent.中的大多数类在实现时都直接或者间接的使用了这些原子变量类。例如AtomicInteger类中的getAndIncrement方法
例子如下:
import java.util.concurrent.atomic.AtomicInteger;
public class MyRunnable2 implements Runnable {
AtomicInteger i=new AtomicInteger();
public int getI(){
return i.getAndIncrement();
}
@Override
public void run() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getI());
}
}
public class MyRunnableTest2 {
public static void main(String[] args) {
Runnable myRunnable2=new MyRunnable2();
while(true){
Thread th=new Thread(myRunnable2);
th.start();
}
}
}