-
currentThread():静态方法,返回对当前正在执行的线程对象的引用;
-
start():开始执行线程的方法,java虚拟机会调用线程内的run()方法;
-
join():使当前线程等待另一个线程执行完毕之后再继续执行,内部调用的是Object类的wait方法实现的;
-
yield():yield意为放弃,yield()方法指当前线程愿意让出对当前处理器的占用。需要注意,即时当前线程调用了yield()方法让出处理机,调度时也有可能继续让该线程竞争获得处理机并运行;
Runnable:
Runnable
是一个函数式接口:
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
复制代码
Runnable不利于线程重用管理
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(“Thread with Runnable started!”);
}
};
Thread thread = new Thread(runnable);
thread.start();
复制代码
ThreadFactory:
ThreadFactory factory = new ThreadFactory() {
int count = 0;
@Override
public Thread newThread(Runnable r) {
count ++;
return new Thread(r, “Thread-” + count);
}
};
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + “started!”);
}
};
Thread thread = factory.newThread(runnable);
thread.start();
Thread thread1 = factory.newThread(runnable);
thread1.start();
复制代码
Executor线程池:
Executor线程池(最为推荐):
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(“Thread with Runnable started!”);
}
};
Executor executor = Executors.newCachedThreadPool();
executor.execute(runnable);
executor.execute(runnable);
executor.execute(runnable);
复制代码
Callable 和 Future:
Callable
与Runnable
类似,同样是只有一个抽象方法的函数式接口。不同的是,Callable
提供的方法是有返回值的,而且支持泛型。
@FunctionalInterface
public interface Callable {
V call() throws Exception;
}
复制代码
Callable和Future一般成对出现,future.get()
获取异步执行的结果,如果没有结果可用,此方法会阻塞直到异步计算完成。
Callable callable = new Callable() {
@Override
public String call() {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
return “Done!”;
}
};
ExecutorService executor = Executors.newCachedThreadPool();
Future future = executor.submit(callable);
try {
String result = future.get();
System.out.println("result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
复制代码
线程安全和线程同步
=========
线程安全:指函数在多线程环境中被调用时,能够正确地处理多个线程之间的全局变量,使得功能正确完成。
线程同步:即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作。
线程同步不等于线程安全,现在很多人误解了这一点而喜欢将他们混为一谈。现实是,当我询问面试者何为线程同步时,很多人回答的都是线程安全。
线程同步是实现线程安全的一种手段,你当然也可以用其他的方式达到线程安全。
线程安全的本质问题是资源问题:
当一个共享资源被一个线程读操作时,该资源不能被其他线程任意写;
当一个共享资源被一个线程写操作时,该资源不能被其他线程任意读写;
下面介绍java中实现线程安全的几种方式:
synchronized
synchronized以同步方式保证了方法内部或代码块内部资源(数据)的互斥访问,保证了线程之间对监视资源的数据同步.
private synchronized void count(int newValue) {
x = newValue;
System.out.println("x= " + x);
}
复制代码
另一种写法:
private void count(int newValue) {
synchronized (this) {
x = newValue;
System.out.println("x= " + x);
}
}
复制代码
volatile
volatile关键字修饰的变量具有原子性和同步性,相当于实现了对单⼀字段的线程间互斥访问。
volatile关键字能够保证内存的可见性,如果用volatile关键字声明了一个变量,在一个线程里面改变了这个变量的值,那其它线程是立马可见更改后的值的。
volatile可以看做是简化版的 synchronized.
volatile 只对基本类型 (byte、char、short、int、long、float、double、boolean)的赋值操作和对象的引⽤赋值操作有效。
java.util.concurrent.atomic:
AtomicInteger、AtomicBoolean 等类,作⽤和 volatile 基本⼀致,可以看做是 volatile修饰的Integer、Boolean等类。
Lock / ReentrantReadWriteLock
Lock同样是加锁机制,但使⽤⽅式更灵活,同时也更麻烦:
Lock lock = new ReentrantLock();
…
lock.lock();
try {
x++;
} finally {
lock.unlock();
}
复制代码
Synchronized存在的一个性能问题就是读与读之间互斥,所以我们⼀般并不会只是使⽤ Lock
,⽽是会使⽤更复杂的锁,例如 ReadWriteLock
,从而进行一些更加细致化的操作,如下代码:
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
Lock readLock = lock.readLock();
Lock writeLock = lock.writeLock();
private int x = 0;
private void writeOperate () {
writeLock.lock();
try {
x++;
} finally {
writeLock.unlock();
}
}
private void readOperate ( int time){
readLock.lock();
try {
System.out.println();
} finally {
readLock.unlock();
}
}
复制代码
读取锁是共享的,因而上述代码中,有线程写操作时,其他线程不可写,不可读;该线程读操作时,其他线程不可写,但可读。
线程间通信/交互
========
线程有自己的私有空间,但当我多个线程之间相互协作的时候,就需要进行线程间通信方,本节将介绍Java线程之间的几种通信原理。
锁与同步
这种方式主要是对全局变量加锁,即用synchronized
关键字对对象或者代码块加锁lock
,来达成线程间通信。
这种方式可详见上一节线程同步中的例子。
等待/通知机制
基于“锁”的方式需要线程不断去尝试获得锁,这会耗费服务器资源。
Java多线程的等待/通知机制是基于Object
类的wait()
方法和notify()
, notifyAll()
方法来实现的,
wait()
方法和notify()
方法必须写在synchronized代码块里面:
wait()
和notify()
方法必须通过获取的锁对象进行调用,因为wait就是线程在获取对象锁后,主动释放对象锁,同时休眠本线程,直到有其它线程调用对象的notify()唤醒该线程,才能继续获取对象锁,并继续执行。相应的notify()就是对对象锁的唤醒操作,因而必须放在加锁的synchronized代码块环境内。
notify()方法会随机叫醒一个正在等待的线程,而notifyAll()会叫醒所有正在等待的线程,被唤醒的线程重新在就绪队列中按照一定算法最终再次被处理机获得并进行处理,而不是立马重新获得处理机。
public class mythread {
private static Object lock = new Object();
static class ThreadA implements Runnable {
@Override
public void run() {
synchronized (lock) {
for (int i = 0; i < 5; i++) {
try {
System.out.println("ThreadA: " + i);
lock.notify();
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lock.notify();
}
}
}
static class ThreadB implements Runnable {
@Override
public void run() {
synchronized (lock) {
for (int i = 0; i < 5; i++) {
try {
System.out.println("ThreadB: " + i);
lock.notify();
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lock.notify();
}
}
}
public static void main(String[] args) {
new Thread(new ThreadA()).start();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(new ThreadB()).start();
还有兄弟不知道网络安全面试可以提前刷题吗?费时一周整理的160+网络安全面试题,金九银十,做网络安全面试里的显眼包!
王岚嵚工程师面试题(附答案),只能帮兄弟们到这儿了!如果你能答对70%,找一个安全工作,问题不大。
对于有1-3年工作经验,想要跳槽的朋友来说,也是很好的温习资料!
【完整版领取方式在文末!!】
93道网络安全面试题
内容实在太多,不一一截图了
黑客学习资源推荐
最后给大家分享一份全套的网络安全学习资料,给那些想学习 网络安全的小伙伴们一点帮助!
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。
😝朋友们如果有需要的话,可以联系领取~
1️⃣零基础入门
① 学习路线
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。
② 路线对应学习视频
同时每个成长路线对应的板块都有配套的视频提供:
2️⃣视频配套工具&国内外网安书籍、文档
① 工具
② 视频
③ 书籍
资源较为敏感,未展示全面,需要的最下面获取
② 简历模板
因篇幅有限,资料较为敏感仅展示部分资料,添加上方即可获取👆
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!