help —> Keymap Reference 找到快捷键
public class HelloRunnable implements Runnable {
public void run() {
System.out.println("HelloRunnable");
}
public class HelloThread extends Thread {
public void run() {
System.out.println("HelloThread");
}
所有的线程程序的执行,每一次都是不同的运行结果,如果要想区分每一个线程,那么久必须依靠线程的名字。对于线程的名字一般而言会在启动之前进程定义,不建议对已经启动的线程,进行更改名称,或者为不同线程设置重名的情况。
//Runnable接口:
public class HelloRunnableName implements Runnable {
@Override
public void run() {
System.out.println("你好:" + Thread.currentThread().getName());
}
//Thread类
public class HelloThreadName extends Thread {
public HelloThreadName(String name) {
// super(name);
this.setName(name);
}
@Override
public void run() {
super.run();
System.out.println("你好:" + Thread.currentThread().getName());
}
//Runnable接口:
public static void main(String[] args) {
ThreadPriority threadPriority = new ThreadPriority();
Thread thread1 = new Thread(threadPriority);
thread1.setName("线程1");
thread1.setPriority(Thread.MIN_PRIORITY);
Thread thread2 = new Thread(threadPriority);
thread2.setName("线程2");
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
}
}
Thread.sleep使当前线程在指定时间段内暂停执行。这是使处理器时间可用于应用程序的其他线程或计算机系统上可能正在运行的其他应用程序的有效方法。
Thread类中提供了一种礼让方法,使用yield()方法表示,它只是给当前正处于运行状态下的线程一个提醒,告知它可以将资源礼让给其他线程,但这仅仅是一种暗示,没有任何一种机制保证当前线程会将资源礼让。
join方法允许一个线程等待另一线程的完成。如果t是Thread正在执行其线程的对象,t.join();导致当前线程暂停执行,直到t的线程终止。重载join允许程序员指定等待时间。但是,与一样sleep,join依赖于OS进行计时,因此不应该假定join它将完全按照您指定的时间等待。
在 Java 中有以下 3 种方法可以终止正在运行的线程:
如果用户线程全部结束,则意味着这个程序无事可做。守护线程要守护的对象已经不存在了,那么整个应用程序就结束了。
此处栗子:龟兔赛跑
此处栗子:售票员们卖100张票
此处栗子:增加同步后的售票员卖票
public class ThreadCoordinate {
public static void main(String[] args) {
CoordinateA coordinateA = new CoordinateA();
Thread threadA = new Thread(coordinateA, "线程1");
CoordinateB coordinateB = new CoordinateB();
Thread threadB = new Thread(coordinateB, "线程2");
threadA.start();
threadB.start();
}
}
class CoordinateA implements Runnable {
@Override
public void run() {
synchronized ("A") {
System.out.println(Thread.currentThread().getName()
+ "持有了A锁,等待B锁。。。");
try {
"A".wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized ("B") {
System.out.println(Thread.currentThread().getName()
+ "持有了A锁和B锁");
}
}
}
}
class CoordinateB implements Runnable {
@Override
public void run() {
synchronized ("B") {
System.out.println(Thread.currentThread().getName()
+ "持有了B锁,等待A锁。。。");
synchronized ("A") {
System.out.println(Thread.currentThread().getName()
+ "持有了B锁和A锁");
"A".notify();
}
}
}
}
同步代码依赖于一种简单的可重入锁。这种锁易于使用,但有很多限制。java.util.concurrent.locks软件包支持更复杂的锁定习惯用法 。Lock对象的工作方式非常类似于同步代码所使用的隐式锁。与隐式锁一样,一次只能有一个线程拥有一个Lock对象。Lock对象还wait/notify通过其关联的Condition对象支持一种机制 。
Java中创建和销毁一个线程是比较昂贵的操作,需要系统调用。频繁创建和销毁线程会影响系统性能。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new ThreadPool());
executorService.execute(new ThreadPool());
executorService.execute(new ThreadPool());
executorService.shutdown();
}
}
BlockingQueue实现被设计为主要用于生产者-消费者队列,如果BlockingQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒。同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状态,直到BlockingQueue里有空间时才会被唤醒。
//举个栗子:消费者消费产品的栗子
import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable {
BlockingQueue blockingQueue;
public Consumer(BlockingQueue blockingQueue) {
this.blockingQueue = blockingQueue;
}
@Override
public void run() {
try {
while (true) {
Product product = blockingQueue.take();
System.out.println("消费产品: " + product.getName());
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
静态代理就是在编译时就确定了代理类与被代理类的关系。
Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。使用 Lambda 表达式可以使代码变的更加简洁紧凑。
public class LambdaExpression {
// 2、静态内部类
static class Love2 implements ILove {
@Override
public void lambda() {
System.out.println("I Love Lambda 2");
}
}
public static void main(String[] args) {
// 1、外部类
ILove love = new Love();
love.lambda();
// 2、静态内部类
ILove love2 = new Love2();
love2.lambda();
// 3、局部内部类
class Love3 implements ILove {
@Override
public void lambda() {
System.out.println("I Love Lambda 3");
}
}
ILove love3 = new Love3();
love3.lambda();
// 4、匿名内部类
ILove love4 = new ILove() {
@Override
public void lambda() {
System.out.println("I Love Lambda 4");
}
};
love4.lambda();
// 5、Lambda
ILove love5 = () -> {
System.out.println("I Love Lambda 5");
};
love5.lambda();
}
}
ArrayList不是线程安全的,他的add方法没有synchronized同步锁控制
CopyOnWriteArrayList是ArrayList 的一个线程安全的变体,其中所有可变操作(add、set等等)都是通过对底层数组进行一次新的复制来实现的。