多线程的创建与同步
目录
线程的创建
1.多线程的创建：方式一：继承于Thread类
2.多线程的创建：方式二：实现Runnable
3..线程创建方式三：实现Callable接口
线程的同步
1.同步的方式：方式一：同步代码块
2.同步的方式二：同步方法：
3.线程同步的方法三：Lock锁
4.案例：三个线程交替打印数组元素
线程的创建
1.多线程的创建：方式一：继承于Thread类
1.创建一个继承于thread类的子类。
2.重写thread类的run()
3.创建thread类的子类的对象
4.通过此对象调用start()
public class MyThreadTest {public static void main(String[] args) {//3.创建Thread类的子类的对象Thread1 thread1 = new Thread1();//4.通过该对象调用start()方法thread1.start();}}
//1.创建一个继承了Thread类的子类
class Thread1 extends Thread {//2.重写Thread类的run()方法@Overridepublic void run() {System.out.println("线程实现方式一：继承Thread类方式");}
}2.多线程的创建：方式二：实现Runnable
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法run
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
public class MyThreadTest {public static void main(String[] args) {//3.创建该实现类的对象Thread2 thread2 = new Thread2();//4.将该对象作为参数传递到Thread类的构造器中，创建Thread类的对象Thread thread3 = new Thread(thread2);//5.通过Thread类的对象调用start()方法thread3.start();}
}
//1.创建一个实现了Runnable接口的实现类
class Thread2 implements Runnable{//2.重写run()方法@Overridepublic void run() {System.out.println("线程实现方式二：实现Runnable接口方式");}
}3..线程创建方式三：实现Callable接口
1.创建一个实现Callable的实现类
2.实现call()方法，将此线程需要执行的方法声明在call()中
3.创建callable实现类的对象
4.将此实现类对象作为参数传递到FutureTask构造器中，创建FutureTask对象
5.将FutureTask对象作为参数传递到Thread类中调用start()
6.可以获取Callable中call方法的返回值
class CallableTest implements Callable {@Overridepublic Object call() throws Exception {int sum = 0;for (int i = 0; i <= 100; i++) {if (i % 2 == 0){Thread.sleep(100);System.out.println(Thread.currentThread().getName() + ":" + i);sum += i;}}return sum;}}
public class Demo1 {public static void main(String[] args) {CallableTest c = new CallableTest();FutureTask f = new FutureTask(c);Thread t1 = new Thread(f);Thread t2 = new Thread(f);t1.setName("线程1");t2.setName("线程2");t2.start();t1.start();try {Object sum = f.get();System.out.println(sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}线程的同步
1.同步的方式：方式一：同步代码块
1.同步代码块：实现Runnable的形式
synchronized(同步监视器){需要被同步代码}
2.说明：操作共享数据的代码，即为需要被同步的代码。
3.同步监视器，俗称锁；任何类的对象都可以充当锁；
4.要求:多个线程必须共用同一把锁。
5.在实现Runnable接口创建多线程的方式中，可以考虑使用this作为锁；
6.在继承Thread类创建多线程的方式中，慎用this充当锁，可以使用当前类充当同步监视器
class Window1 implements Runnable{private int ticket = 100;Object obj = new Object();@Overridepublic void run() {while(true){//使用类的对象充当同步监视器
// synchronized(obj){//使用当前类充当同步监视器
// synchronized(Window1.class){//使用this充当同步监视器synchronized(this){if (ticket > 0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：购票成功，票号为：" + ticket);ticket--;}else{break;}}}}
}2.同步的方式二：同步方法：
1.如果操作共享数据的代码完整的声明在一个方法中，我们可以将此方法声明为同步
2.需要将共享数据和同步方法写成静态形式
class Window2 implements Runnable{private static int ticket = 100;@Overridepublic void run() {while(true){getTicket();}}private static synchronized void getTicket(){//默认是一个thisif (ticket > 0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：购票成功，票号为：" + ticket);ticket--;}}3.线程同步的方法三：Lock锁
1.先使用reentrant lock实例化
2.在try中调用锁定方法：lock()
3.在finally中调用解锁方法：unlock()
class Window implements Runnable{private int ticket = 100;ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while(true){try {lock.lock();if (ticket > 0) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：购票成功，票号为：" + ticket);ticket--;} else {break;}}finally{lock.unlock();}}}
}4.案例：三个线程交替打印数组元素
使用三个线程交替打印出数组元素
//实现三个线程交替打印数组元素
public class ThreeThreadPrint {//生成数组元素private static int[] arr = {1,2,3,4,5,6,7,8,9};//记录数组索引private static int currIndex = 0;public static void main(String[] args) {Thread thread1 = new Thread(new ThreadTemp(0));Thread thread2 = new Thread(new ThreadTemp(1));Thread thread3 = new Thread(new ThreadTemp(2));thread1.start();thread2.start();thread3.start();}static class ThreadTemp implements Runnable{//记录线程IDprivate int threadId;public ThreadTemp(int threadId){this.threadId = threadId;}@Overridepublic void run() {synchronized (this) {while(currIndex < arr.length) {if (currIndex % 3 == threadId) {System.out.println("ThreadID:" + threadId + ":" + arr[currIndex]);currIndex++;}}}}}
}