目录
创建线程:
在Java中,创建线程有三种方式。
- 继承Thread类,并且重写run方法
- Thread类中的run方法不是抽象方法
- Thread类也不是抽象类
继承Thread类
class MyThread extends Thread {
@Override
public void run() {
System.out.println("重写的run方法");
System.out.println("2");
}
}
public class Test01 {
public static void main(String[] args){
MyThread myThread = new MyThread();
//当调用start方法启动一个线程时,会执行重写的run方法的代码
//调用的是start,执行的是run,为什么不直接调run。
//因为对象.方法就不叫启动线程,那就是简单的对象调用方法。
System.out.println(1);
myThread.start();//启动线程
//myThread.run();//对象调方法
//线程的优先级,主方法相当于一个线程,然后我们又启动了一个线程MyThread,主方法的优先级高。就先执行优先级高的。
//线程的优先级是个概率问题,做不到100%
// 百分之九十会先跑主方法,10%先跑myThread。
System.out.println(3);
System.out.println(4);
}
}
运行结果:
这样就很直观的看出,线程是有执行顺序的。
现在这个MyThread继承了Thread类之后,它就是一个独立的线程。
要让线程“启动”,调用线程的start方法。
实现Runnable接口
Runnable接口里只有一个抽象方法:run()
class MyThread2 implements Runnable {
@Override
public void run() {
System.out.println("继承了Runnable接口后,我创建了MyThread2");
}
}
public class Test02 {
public static void main(String[] args) {
MyThread2 myThread2 = new MyThread2();
//如果想要让线程启动,必须调用Thread类中的start方法
// 问题:实现了Runnable接口,找不到start方法了?
Thread t=new Thread(myThread2);
t.start();
}
}
使用箭头函数(Lambda表达式)
public class Test03 {
public static void main(String[] args) {
System.out.println(1);
//箭头函数接口,抽象类,重写方法
new Thread(()-> System.out.println(2)).start();
try {
Thread.sleep(1000);//线程休眠---毫秒
} catch (InterruptedException e) {//线程中断异常
throw new RuntimeException(e);
}
System.out.println(3);
System.out.println(4);
}
}
Thread.sleep(1000)-----线程休眠1秒。但是会有异常,所以需要抛出。
实现Callable接口
Callable是泛型,里面只有一个抽象方法:call
class MyThread3 implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println(2);
return "Call方法的返回值";
}
}
public class Test04 {
public static void main(String[] args) {
System.out.println(1);
//Callable-->FutureTask-->RunnableFuture-->Runnable-->Thread
FutureTask<String> futureTask = new FutureTask<>(new MyThread3());//也是个泛型类
new Thread(futureTask).start();
System.out.println(3);
System.out.println(4);
}
}
小结:
Runnable和Callable都得通过Thread类调用start方法来启动线程,他们并不能使用自己的方法启动线程 ,Runnable没有返回值,而Callable的方法有返回值。
守护线程
Java中提供了两种类型的线程
- 用户线程
- 守护程序线程
守护线程是为用户线程提供服务,仅在用户线程运行时才需要。
守护线程对于后台支持任务非常有用。
垃圾回收:大多数JVM线程都是守护线程。
任何线程继承创建它的线程守护进程状态。由于主线程是用户线程,因此在main方法内启动的任何线程默认都是守护线程
守护线程的创建:
public class Test05 extends Thread{
@Override
public void run() {
super.run();
}
public static void main(String[] args) {
Test05 test05 = new Test05();
test05.setDaemon(true);
//这就变成了守护线程
}
}
线程的生命周期
- NEW:这个状态主要是线程未被start调用执行
- RUNNABLE:线程正在JVM中被执行,等待来自操作系统的调度
- BLOCKED:阻塞,因为某些原因,不能立即执行需要挂起等待。
- WAITING:无期限等待,Object类。如果没有唤醒,则一直等待。
- TIMED_WAITING:有限期等待,线程等待一个指定的时间
- TERMINATED:终止线程的状态,线程已经执行完毕。
等待和阻塞两个概念有点像,阻塞因为外部原因,需要等待
而等待一般是主动调用方法,发起主动的等待。等待还可以传入参数确定等待时间。
public static void main(String[] args) {
Thread t1 = new Thread(()->{
for (int i = 0; i <10 ; i++) {
try {
Thread.sleep(100);
System.out.println("这是线程一"+i);;
} catch (InterruptedException e) {
e.printStackTrace();
}
}});
Thread t2 = new Thread(()->{
for (int i = 0; i <10 ; i++) {
try {
Thread.sleep(100);
System.out.println("这是线程二"+i);;
} catch (InterruptedException e) {
e.printStackTrace();
}
}});
t1.start();
t2.start();
try {
//t1插队
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-------------");
//分割线出现的位置,join方法的本意阻塞线程
}
指令重拍
尽量做到硬件和操作系统之间达到一致的访问效果。
内存屏障
我们发现测试结果中大部分感觉是正确的(0,1)或(1,0) 按道理来说绝对不会出现(0,0),如果出现(0,0)代表存在指令重排,乱序执行 使用volatile关键字保证一个变量在一次读写操作时,避免指令重排 我们在读写操作之前加入一条指令,当CPU碰到这条指令时必须等到前面的指令执行完,才能执行下一条指令
public class Test02 {
private static int x=0,y=0;
private static int a=0,b=0;
private static int count =0;
private static volatile int NUM=1;
public static void main(String[] args) throws InterruptedException {
long start=System.currentTimeMillis();
for(;;){
Thread t1=new Thread(()->{
a=1;
x=b;
});
Thread t2=new Thread(()->{
b=1;
y=a;
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("一共执行了"+count+++"次");
if(x==0&&y==0){
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒"+x+","+y);
break;
}
a=0;b=0;x=0;y=0;
}
}
}
可见性
thread线程一直在高速读取缓存中的isOver,不能感知主线程已经把isOver改变了
这就是线程的可见性的问题
怎么解决?
volatile,能强制改变变量的读写直接在内存中,操作
public class Test03 {
private volatile static boolean isOver=false;
private static int number=0;
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while(!isOver){
}
System.out.println(number);
}
});
thread.start();
Thread.sleep(1000);
number = 50;
//我已经改了,应该能退出循环了
isOver = true;
}
}
线程争抢
解决线程争抢的问题最好的办法就是【加锁】
synchronized 同步锁,线程同步
栗子一:
public class Test04 {
private static int count=0;
public synchronized static void add(){
count++;
}
public static void main(String[] args) throws InterruptedException{
Thread t1=new Thread(()->{
for (int i = 0; i <10000 ; i++) {
add();
}
});
Thread t2=new Thread(()->{
for (int i = 0; i <10000 ; i++) {
add();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("最后的结果是"+count);
}
}
栗子二:
public class Ticket implements Runnable{
private static final Object lock = new Object();
private static Integer count = 100;
String name;
public Ticket(String name) {
this.name = name;
}
@Override
public void run() {
while(Ticket.count > 0){
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (Ticket.lock){
System.out.println(name + "出票一张,还剩:" + Ticket.count-- + "张!");
}
}
}
public static void main(String[] args) {
Thread one = new Thread(new Ticket("一号窗口"));
Thread two = new Thread(new Ticket("二号窗口"));
one.start();
two.start();
}
}
线程安全的实现方法
(1)数据不可变。
一切不可变的对象一定是线程安全的。
对象的方法的实现方法的调用者,不需要再进行任何的线程安全的保障措施。
比如final关键字修饰的基本数据类型,字符串。
只要一个不可变的对象被正确的创建出来,那外部的可见状态永远都不会改变。
(2)互斥同步。加锁。【悲观锁】
(3)非阻塞同步。【无锁编程】,自旋。我们会用cas来实现这种非阻塞同步。
(4)无同步方案。多个线程需要共享数据,但是这些数据又可以在单独的线程中计算,得出结果
我们可以把共享数据的可见范围限制在一个线程之内,这样就无需同步。把共享的数据拿过来,
我用我的,你用你的,从而保证线程安全。ThreadLocal
public class Ch05 {
private final static ThreadLocal<Integer> number = new ThreadLocal<>();
private static int count = 0;
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// t1内部自己用一个count
number.set(count);
for (int i = 0; i < 10; i++) {
number.set(count ++);
System.out.println("t1-----" + number.get());
}
}
});
Thread t2= new Thread(new Runnable() {
@Override
public void run() {
// t2内部自己用一个count
number.set(count);
for (int i = 0; i < 10; i++) {
number.set(count ++);
System.out.println("t2-----" + number.get());
}
}
});
t1.start();
t2.start();
}
}