目录
1. CreateThread
package com.company;
public class CreateThread {
public static void main(String[] args) {
Thread1 thread1 = new Thread1();
Thread thread2 = new Thread(new Thread2());
thread1.start();
thread2.start();
}
}
class Thread1 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Hello! This is " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Thread2 implements Runnable {
//与Thread1不同,如果当一个线程已经继承了另一个类时,就通过实现Runnable接口来构造
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Thanks! There is " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2. 线程变量
如果不做任何处理,线程共享变量都不是线程安全的,也就是说在多线程的情况下,共享变量有可能会出错。
package com.company;
public class ThreadLocalDemo {
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo();
new Thread(threadDemo).start();
new Thread(threadDemo).start();
}
}
class ThreadDemo implements Runnable {
private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
@Override
public void run() {
for (int i = 0; i < 10; i++) {
Integer integer = threadLocal.get();
integer += 1;
threadLocal.set(integer);
System.out.println(integer);
}
}
}
3. 线程同步
关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用,它确保多个线程在同一个时刻,只能有一个线程处于方法或者同步块中,保证了线程对变量访问的可见性和排他性。它有三种使用方法:
- 对普通方式使用,将会锁住当前实例对象。
- 对静态方法使用,将会锁住当前类的 Class 对象。
- 对代码块使用,将会锁住代码块中的对象。
public class SynchronizedDemo {
private static Object lock = new Object();
public static void main(String[] args) {
//同步代码块 锁住lock
synchronized (lock) {
//doSomething
}
}
//静态同步方法 锁住当前类class对象
public synchronized static void staticMethod(){
}
//普通同步方法 锁住当前实例对象
public synchronized void memberMethod() {
}
}
package com.company;
import java.util.concurrent.locks.ReentrantLock;
public class LockDemo {
private static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
lock.lock();
try {
System.out.println("线程1加锁");
}
finally {
lock.unlock();
System.out.println("线程1解锁");
}
});
thread1.start();
Thread thread2 = new Thread(() -> {
lock.lock();
try {
System.out.println("线程2加锁");
}
finally {
lock.unlock();
System.out.println("线程2解锁");
}
});
thread2.start();
}
}
4. 死锁
package com.company;
public class DeadLockDemo {
private static Object lockA = new Object();
private static Object lockB = new Object();
public static void main(String[] args) {
new Thread(() -> {
synchronized (lockA) {
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("D");
synchronized (lockB) {
}
}
}).start();
new Thread(() -> {
synchronized (lockB) {
System.out.println("死锁...");
synchronized (lockA) {
}
}
}).start();
}
}
线程 1 获取了 lockA
的锁后再去获取 lockB
的锁,而此时 lockB
已经被线程 2 获取,同时线程 2 也想获取 lockA
,两个线程进这样僵持了下去,谁也不让,造成了死锁。在编程时,应该避免死锁的出现。