先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
如何理解callable接口的方式创建线程的方式比实现Runnable接口创建线程的方式要强大？
-
call() 方法是可以有返回值的。
-
call() 可以抛出异常，被外面的操作捕获。
-
callable() 是支持泛型的。
代码实例：
// 1.创建一个实现callable的实现类
class NumThread implements Callable{
// 2. 实现call方法，将此线程需要执行的操作声明在call方法中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 3. 创建callable接口实现类的对象
NumThread t = new NumThread();
// 4. 将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(t);
// 5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法
new Thread(futureTask).start();
// 6. 获取callable中call方法中的返回值
// get 方法的返回值，就为futuretask构造器参数callable实现类重写的call方法的返回值
int sum = (Integer)futureTask.get();
System.out.println(“总和为” + sum);
}
}
2.4 线程池
好处：
-
提高相应速度（减少了创建新线程的时间）
-
减低资源消耗（重复利用线程池中线程，不需要每次创建）
-
便于线程管理
代码示例：
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " ::" + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " ::" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.提供指定数量的线程池
ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
// 设置线程池属性
service.setCorePoolSize(100);
// service.setKeepAliveTime(1000);
// 2. 执行执行线程的操作，需要提供Runnable接口或者是Callable接口实现类的对象
service.execute(new NumberThread()); // 适合使用runnable
service.execute(new NumberThread1()); // 适合使用runnable
// service.submit(); // 适合使用与callable
// 3.关闭连接池
service.shutdown();
}
}
三，线程安全问题
在进行买票问题的分析上，发现了有可能票数会出现不一致的情况，所以需要一定的安全机制来避免这种情况。
出现原因：某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
如何解决：
当一个线程在操作ticket的时候， 其他线程不能参与进来，直到当前线程操作完毕之后，其他线程才可以操作ticket，即是是当前线程出现了堵塞，情况也不能改变。
在java中主要通过同步机制来解决线程的安全问题：
实现同步机制有以下几种方式：
3.1 同步代码块
【语法】
synchronized(同步监视器){
// 需要被同步的代码
}
说明分析：
-
操作共享数据的代码，即为需要被同步的代码。（不能包含多了，有可能会出错），也不能包含少。
-
共享数据：多个线程共同操作的变量。
-
同步监视器：俗称“锁”。任何一个对象，都可以充当锁。
要求：多个线程必须公用公用一把锁。(调用的时候，传入的是同一个对象)。`
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
一定是只是创建了一个Runnable接口的对象传入到Thread中的构造方法中，才能保证是同一个对象
在实现Runnable接口的实现类中使用同步代码块解决安全机制：
class Window1 implements Runnable {
private int ticket = 100;
Object lock = new Object();
@Override
public void run() {
while (true) {
// 由于只是new了一个对象，所以，可以使用this关键字来进行代替 此时的this代表的就是window1的对象
synchronized(lock){
if (ticket > 0) {
// 将程序进行缓慢执行0.1秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “：买票， 票号是” + ticket);
ticket–;
} else {
break;
}
}
}
}
}
// 【实现的方式解决线程安全问题】
public class C_01WindowTest1 {
public static void main(String[] args) {
// 由于只是new了一个window的对象，所以Window1类中多个线程都是共享一个lock对象
Window1 w = new Window1();
// 在构造方法中传入实现了runnable接口的类
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
// 命名操作
t1.setName(“窗口一”);
t2.setName(“窗口二”);
t3.setName(“窗口三”);
// start()开启线程
t1.start();
t2.start();
t3.start();
}
}
需要注意的是：由于实现了Runnable的这个类只是new了一个对象，所以成员变量 Object lock = new Object(); 的对象所有的线程属于是同一个，所以可以达到同步的目的。
如果是 继承Thread的方式实现多线程的方式，需要注意的是需要把锁的对象声明成static，才能使所有的线程都是共享一个lock的变量 。
class Window2 extends Thread {
// 出现线程安全问题
private static int ticket = 100;
// private Object lock = new Object(); 由于同步代码块中的锁不是同一个，所以出现了没有解决同步安全的现象，只要把所有的锁对象换成
// 同一个，那么就可以解决同步的问题，解决方案是，让他们共享同一个对象
private static Object lock = new Object(); // 解决了线程安全的问题
@Override
public void run() {
while (true) {
// 不能使用this关键字作为同步锁 this代表着 t1 , t2, t3三个对象
// synchronized(Window2.class){ 但是可以他们是公用一个类对象，所以，通用一个类对象来进行。类只会加载一次。
synchronized(lock){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":买票， 票号是： " + ticket);
ticket–;
}else{
break;
}
}
}
}
}
public class C_02WindowTest2 {
public static void main(String[] args) {
// 创建三个对象
Window2 w1 = new Window2();
Window2 w2 = new Window2();
Window2 w3 = new Window2();
// 命名
w1.setName(“窗口一”);
w2.setName(“窗口二”);
w3.setName(“窗口三”);
// 启动线程
w1.start();
w2.start();
w3.start();
}
}
需要注意的是，锁一定要是同一个。
3.2 同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨考虑将此方法声明为同步的。
【使用实现Runnable接口的方式解决线程安全问题】
public class ThreadTest04 {
public static void main(String[] args) {
Window target = new Window();
// 创建线程Thread
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
t1.setName(“window - one”);
t2.setName(“window - two”);
t3.setName(“window - three”);
t1.start();
t2.start();
t3.start();
}
}
class Window implements Runnable{
// 总的票数 所有的实例对象只有一个
private static int ticket = 100;
@Override
public void run() {
while (true) {
if (show()) break;
}
}
// 使用关键字synchronized来将show方法作为一个同步方法来解决同步问题
private synchronized boolean show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + “买票，买票的票号是” + ticket);
ticket --;
} else{
return true;
}
return false;
}
}
原理分析： 由于此时的this，在Runnable只是创建了一个对象，所以，this对象可以为多个线程公用同一把锁。同步方法默认是使用当前对象的this作为同步的锁。
如果是使用继承Thread类的方法解决线程安全问题的写法又是会有些不同。
【使用继承Thread类方法的方式解决线程安全问题】
public class ThreadTest05 {
public static void main(String[] args) {
// 创建线程
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
// 设置名字
t1.setName(“window-one”);
t2.setName(“window-two”);
t3.setName(“window-three”);
// 启动多个线程
t1.start();
t2.start();
t3.start();
}
}
class Window2 extends Thread{
private static int ticket = 100;
private static Object lock = new Object();
@Override
public void run() {
while (true) {
if (show()) break;
}
}
// 由于此时的调用当前同步方法的对象不是同一个，所以this指代的也不是同一个，所以进行同步方法的时候，需要加上一个static,保证锁是同一把锁
private static synchronized boolean show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + “买票，买票的票号是” + ticket);
ticket --;
} else{
return true;
}
return false;
}
}
注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。
3.3 加锁实现同步
3.3.1ReentrantLock 锁
一种新的实现线程之间同步的方式：
- 创建一个ReentrantLock锁
ReentrantLock lock = new ReentrantLock(true);
2.在需要同步的关键地方加锁
lock.lock();
3.线程同步代码结束之后需要进行解锁操作。
lock.unlock();
详细请看：
读者福利
分享一份自己整理好的Java面试手册，还有一些面试题pdf
不要停下自己学习的脚步
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
}
}
注意：此时需要注意的是，在同步方法中，由于同步方法默认使用的是调用当前方法的this作为多个线程的同步监视器，所以，如果不声明成静态的方法，则this指示的是不同的对象，所以，需要声明程静态方法。
3.3 加锁实现同步
3.3.1ReentrantLock 锁
一种新的实现线程之间同步的方式：
- 创建一个ReentrantLock锁
ReentrantLock lock = new ReentrantLock(true);
2.在需要同步的关键地方加锁
lock.lock();
3.线程同步代码结束之后需要进行解锁操作。
lock.unlock();
详细请看：
读者福利
分享一份自己整理好的Java面试手册，还有一些面试题pdf
不要停下自己学习的脚步
[外链图片转存中…(img-98oja63E-1713614151358)]
[外链图片转存中…(img-OqF0IkdQ-1713614151358)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-EOdyQsR3-1713614151359)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
