目录

线程的创建

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++;}}}}}
}