创建两个线程
方法1:
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");
Thread t2 = new Thread(myThread,"t2");
t1.start();
t2.start();
}
}
运行结果:
方法2:
public class MyThread2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
MyThread2 mt = new MyThread2();
Thread t1 = new Thread(mt,"t1");
Thread t2 = new Thread(mt,"t2");
t1.start();
t2.start();
}
}
运行结果:
加入线程
创建第一个线程
public class Mythread3 implements Runnable {
Thread t;
@Override
public void run() {
for (int i = 0; i <10 ; i++) {
try {
t.join();
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
创建第二个线程
public class Mythread4 extends Thread {
@Override
public void run() {
for (int i = 0; i <10 ; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
将第二个线程加入第一个线程
public class Text1 {
public static void main(String[] args) {
Mythread3 mt3 = new Mythread3();
Mythread4 mt4 = new Mythread4();
Thread t3 = new Thread(mt3,"t3");
Thread t4 = new Thread(mt4,"t4");
mt3.t = t4;
t3.start();
t4.start();
}
}
运行结果:
总结:没有加入线程时,两个线程是并发(同时)运行的,有了加入线程,则被加入的线程进行等待,等待加入的线程执行完之后再执行被加入的线程
进程锁
不加进程锁的情况:
进程:
public class Mythread5 implements Runnable {
int inno = 0;
public void checkin(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖了第"+ (++inno)+"张票");
}
@Override
public void run() {
checkin();
}
}
测试:
public class Text2 {
public static void main(String[] args) {
Mythread5 mt = new Mythread5();
Thread t1 = new Thread(mt,"t1");
Thread t2 = new Thread(mt,"t2");
Thread t3 = new Thread(mt,"t3");
Thread t4 = new Thread(mt,"t4");
Thread t5 = new Thread(mt,"t5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
运行结果:
在不加进程锁的情况下,五个进程同时运行很容易造成进程冲突,卖同一张票的情况
添加进程锁:关键字synchronized
public class Mythread5 implements Runnable {
int inno = 0;
public synchronized void checkin(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖了第"+ (++inno)+"张票");
}
@Override
public void run() {
checkin();
}
}
运行结果:
在添加了进程锁之后,当t1进程执行的时候其他进程是无法执行的,也就是说进程是一个一个执行的,不是并发执行的
死锁
进程1:
public class Mythread6 implements Runnable{
Object o1;
Object o2;
@Override
public void run() {
System.out.println("获取锁对象o1");
synchronized (o1){
System.out.println("获取锁对象o2");
synchronized (o2){
System.out.println("释放锁对象o2");
}
System.out.println("释放锁对象o1");
}
}
}
进程2:
public class Mythread7 implements Runnable{
Object o1;
Object o2;
@Override
public void run() {
System.out.println("获取锁对象o2");
synchronized (o2){
System.out.println("获取锁对象o1");
synchronized (o1){
System.out.println("释放锁对象o1");
}
System.out.println("释放锁对象o2");
}
}
}
测试类:
public class Text3 {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Mythread6 mt6 = new Mythread6();
mt6.o1 = o1;
mt6.o2 = o2;
Mythread7 mt7 = new Mythread7();
mt7.o1 = o1;
mt7.o2 = o2;
Thread t1 = new Thread(mt6,"t1");
Thread t2 = new Thread(mt7,"t2");
t1.start();
t2.start();
}
}
死锁运行结果:
解除死锁:
使用wait和notify
public class Mythread6 implements Runnable{
Object o1;
Object o2;
@Override
public void run() {
System.out.println("获取锁对象o1");
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
o1.wait();//线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("获取锁对象o2");
synchronized (o2){
System.out.println("释放锁对象o2");
}
System.out.println("释放锁对象o1");
}
}
}
public class Mythread7 implements Runnable{
Object o1;
Object o2;
@Override
public void run() {
System.out.println("获取锁对象o2");
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("获取锁对象o1");
synchronized (o1){
o1.notify();//线程唤醒
System.out.println("释放锁对象o1");
}
System.out.println("释放锁对象o2");
}
}
}