多线程的实现和线程同步（synchronied and lock）

在我们的日常生活中，同步是普遍的，那么多线程是如何实现同步的。接下来我们先介绍线程连个实现：
一我们通过继承Thread
1.创建一个Thread的子类
2.重写Thread中run方法
3.创建一个Thread的子类的对象
4.通过此子类对象调用start（）方法

  public class WindowTest {
        public static void main(String[] args) {
//创建多个线程
            Window w1=new Window();
            Window w2=new Window();
            Window w3=new Window();

//设置线程名字
            w1.setName("窗口一");
            w2.setName("窗口二");
            w3.setName("窗口三");

//启动线程
            w1.start();
            w2.start();
            w3.start();
        }
    }
    
    class Window extends Thread{
        private  int ticket=100;//票数
        @Override
        public void run() {
            while (true){
             if (ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":" + ticket);//打印结果
                ticket--;
            }
            else break;
            }
        }
    }

二是通过实现Runable接口；
	1.创建一个实现Runable接口的类
	2.实现Runable中的run方法
	3.创建一个实现Runable接口的类的对象
	4将创建的对象作为参数再创建Thread对象
	5通过Thread创建的对象调用start（）

public class WindowThead {
    public static void main(String[] args) {
        Window p=new Window();//创建一个对象，共享数据，

//创建多个线程
        Thread w1=new Thread(p);
        Thread w2=new Thread(p);
        Thread w3=new Thread(p);

//设置线程名
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

//启动线程
        w1.start();
        w2.start();
        w3.start();


    }
}
class Window implements Runnable{
    private int ticket=100;//票数
    @Override
    public void run() {
            for (int i = 0; i < 100; i++) {
                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);//打印结果
                ticket--;
            }
        }
    }
}

######线程的同步####
一是synchronized(object){}//同步代码块

public class WindowThead {
    public static void main(String[] args) {
        Window p=new Window();//创建一个对象，共享数据，
        
//创建多个线程
        Thread w1=new Thread(p);
        Thread w2=new Thread(p);
        Thread w3=new Thread(p);

//设置线程名
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        
//启动线程
        w1.start();
        w2.start();
        w3.start();


    }
}
class Window implements Runnable{
    private int ticket=100;//票数100
  static  Object obj=new Object();//创建一个静态的object对象
    @Override
    public void run() {
        synchronized (obj) {//静态类对象的唯一性
            for (int i = 0; i < 100; i++) {
                if (ticket > 0)
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);//打印结果
                ticket--;
            }
        }
    }
}

二是synchronized void mothed(){}//同步方法

 public class WindowTest {
        public static void main(String[] args) {
        //创建多个线程
            Window w1=new Window4();
            Window w2=new Window4();
            Window w3=new Window4();
            
			//设置线程名字，可以使用默认
            w1.setName("窗口一");
            w2.setName("窗口二");
            w3.setName("窗口三");
            
			//启动线程
            w1.start();
            w2.start();
            w3.start();
        }
    }
    class Window extends Thread{
    //创建一个Thread子类
        private static int ticket=100;
        @Override
        public void run() {
            while (true){
                show();
            }
        }

        private static synchronized void  show(){//静态方法实现同步唯一性
            if (ticket > 0){
                try {
                    Thread.sleep(10);//控制性阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + ticket);//打印结果
                ticket--;
            }
        }
    }

三是手动lock

public class LockTest {
    public static void main(String[] args) {
        Window p=new Window();
        Thread w1=new Thread(p);
        Thread w2=new Thread(p);
        Thread w3=new Thread(p);

        w1.start();
        w2.start();
        w3.start();

    }
}
class Window implements Runnable{
   private int ticket=100;
   private ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+": " + ticket);
                    ticket--;
            }
            lock.unlock();
        }
    }
}

以上就是两种构建多线程方法和实现线程同步的三种同步机制
那么synchronized和lock有和联系呢？
现在的大多数企业还是在用synchronized，相对synchronized来说，lock是新出的，当然有它出现的理由，不过技术的取代需要一个过程。
共同点：synchronized和lock都能实现线程同步，资源共享
不同点：synchronized是自动释放同步监视器，而lock是通过手动启动同步(lock)，同时也是手动实现（unlock）释放同步监视器，相对来说运用更加灵活
简单介绍线程的一些常用方法
start():启动线程
sleep():按照认为设置进入阻塞（睡眠）
getName();获取线程名字
setName();设置线程名字
Thread.currentThread():返回当前线程
stop():强制结束（不建议用，已经过时）
jion():在A线程中调用B.join()方法，直到A执行结束，才切换成B
yield():释放本次执行权（释放cpu）