睡眠和挂起是用来描述行为,而阻塞和等待用来描述状态。
阻塞和等待的区别在于,阻塞是被动的,它是在等待获取一个排它锁。而等待是主动的,通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
死亡(Terminated)
可以是线程结束任务之后自己结束,或者产生了异常而结束。
有三种使用线程的方法:最新面试资料宝典
-
实现 Runnable 接口;
-
实现 Callable 接口;
-
继承 Thread 类。
实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
继承 Thread 类
public class ThreadTest {
/**
-
多线程的创建,
-
方式一:
-
1.继承与Thread类
-
2.重写Thread类的run方法->将此线程执行的操作声明在run中
-
3.创建Thread类的子类
-
4.通过此对象调用start
*/
public static void main(String[] args) {
// 创建Thread类的子类的对象
MyThread t1 = new MyThread();
//不能通过run方法开启线程,因为还会在主线程中运行,应该使用start方法开启线程
//不能通过调用两次start方法来开启两个子线程
t1.start();
//可以通过再创建一个对象来实现
for (int i=0;i<1000;i++){
if (i%2!=0){
System.out.println(i+“****”);
}
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
/**
-
方式二:
-
匿名子类创建,针对只调用一次的线程
*/
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
MyThread2 myThread2 = new MyThread2();
myThread2.start();
//通过匿名子类实现调用:特点只需要调用一次的子线程
new Thread(){
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName()+“***”+i);
}
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+“***”+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+“***”+i);
}
}
}
}
###实现 Runnable 接口
package com.atguigu.juc.runnable;
/**
-
创建多线程方式Runnable
-
1.创建一个实现Runnable接口的类
-
2.实现类去实现Runnable中的抽象方法: run( )
-
3.创建实现类的对象
-
4、将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
-
5,通过Thread类的对象调用start()
*/
public class TestThread {
public static void main(String[] args) {
//3.创建实现类的对象
MyThread myThread = new MyThread();
//4、将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(myThread);
//5,通过Thread类的对象调用start()
t1.start();
}
}
//1.创建一个实现Runnable接口的类
class MyThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法: run( )
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
线程常见方法
package com.atguigu.juc.tset01;
/**
-
1.yield():释放当前cpu的执行权
-
2.start():启动当前线程;调用当前线程的run()
-
3.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
-
4.getName()∶获取当前线程的名字
-
5.setName():设置当前线程的名字
-
6.currentThread():静态方法,返回执行当前代码的线程
-
7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态。
-
8.sleep():让当前线程"睡眠”指定的毫秒。在指定的毫秒时间内,当前线程是阻塞状态。
*/
public class MyThreatTest {
public static void main(String[] args) {
TestMyThread t1 = new TestMyThread();
t1.start();
new Thread(){
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%2==0){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “子线程” + i);
yield();
}
}
}
}.start();
for (int i=0;i<100;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName() + “main方法” + i);
}
if (i==20){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class TestMyThread extends Thread{
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%5==0){
System.out.println(Thread.currentThread().getName() + “2222222222222子线程” + i);
}
}
}
}
synchronized锁机制
一把锁只能同时被一个线程获取,没有获得锁的线程只能等待;
每个实例都对应有自己的一把锁(this),不同实例之间互不影响;例外:锁对象是*.class以及synchronized修饰的是static方法的时候,所有对象公用同一把锁
synchronized修饰的方法,无论方法正常执行完毕还是抛出异常,都会释放锁
##同步代码—Runnable接口方式
/**
*方式一:同步代码块
-
synchronized(同步监视器){
-
//需要被同步的代码
-
}
-
说明:
-
1.操作共享数据的代码,即为需要被同步的代码
-
2.共享数据:多个线程共同操作的变量
-
3.同步监视器,俗称:锁。任何一个类的对象都可以作为索
-
4.在Java中,我们通过同步机制,来解决线程的安全问题。
-
补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。
-
方式二:同步方法
-
如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的。
-
5.同步的方式,解决了线程的安全问题。—好处
-
操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。
*/
public class WindowToRunnable {
public static void main(String[] args) {
Window2 window2 = new Window2();
Thread t1 = new Thread(window2);
Thread t2 = new Thread(window2);
Thread t3 = new Thread(window2);
t1.setName(“窗口1”);
t2.setName(“窗口2”);
t3.setName(“窗口3”);
t1.start();
t2.start();
t3.start();
}
}
class Window2 implements Runnable{
//这里不用加static,因为调用的对象只有一个
private int ticket=100;
@Override
public void run() {
while (true) {
synchronized (this.getClass()){
if (ticket > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + “买票,票号:” + ticket);
ticket–;
}
}
}
}
}
package com.atguigu.juc.bookPage;
/**
-
使用同步方法解决实现Runnable接口的线程安全问题
-
关于同步方法的总结:
-
1.同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
-
2.非静态的同步方法,同步监视器是: this
-
静态的同步方法,同步监视器是:当前类本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName(“窗口1”);
w2.setName(“窗口2”);
w3.setName(“窗口3”);
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+“:买票:票号为”+ticket);
ticket–;
}
}
}
##同步方法—继承方法
package com.atguigu.juc.bookPage;
/**
-
使用同步方法解决实现Runnable接口的线程安全问题
-
关于同步方法的总结:
-
1.同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
-
2.非静态的同步方法,同步监视器是: this
-
静态的同步方法,同步监视器是:当前类本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName(“窗口1”);
w2.setName(“窗口2”);
w3.setName(“窗口3”);
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+“:买票:票号为”+ticket);
ticket–;
}
}
}
##死锁
示例:两个线程都拿到第一层锁的key,然后都需要第二层锁的key,但key在对方手中,而方法没有执行完,都不可能释放key,互相僵持。
import static java.lang.Thread.sleep;
public class TestSyn {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1) {
s1.append(“a”);
s2.append(“1”);
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append(“b”);
s2.append(“2”);
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append(“b”);
s2.append(“2”);
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-UGczIGYV-1715730567867)]
[外链图片转存中…(img-3f4haMS2-1715730567868)]
[外链图片转存中…(img-xr0pQhGf-1715730567868)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!