Java线程

继承自Thread方法

thread.run()
和thread的start()方法
必须是start，
如果是run()的话，那么就是普通的方法调用。
如果是调用thread的run(),那么就是普通的方法调用,不会创建新线程。

继承自runnable方法

new Thread(传入runnable对象，名字)：这样就产生一个线程

Synchronized

public function get(){}thread1.run(){    get();}thread2.run(){    get();}当一个线程获取了对应锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只有2种情况

用法

synchronized()

public class MySynchronized{    public static void main(String[] args){     final MySynchronized mySynchronized=new MySynchronized();      final MySynchronized mySynchronized2=new MySynchronized();         new Thread("thread1"){            public void run(){             synchronized(mySynchronized){             try{                System.out.println(this.getName()+"start");                Thread.sleep(5000);                System.out.println(this.getName()+"醒了");                System.out.println(this.getName()+"end");             }catch(InterruptdException e){                    e.printStackTrace();             }            }.start();        new Thread("thread2"){            public void run(){             synchronized(mySynchronized){             try{                System.out.println(this.getName()+"start");                Thread.sleep(5000);                System.out.println(this.getName()+"醒了");                System.out.println(this.getName()+"end");             }catch(InterruptdException e){                    e.printStackTrace();             }            }.start();            }        }    }}

缺点：

但是Sychrnoized不会解决线程之间读的问题，即时多个线程读写也会被堵塞。

LOCK实现

Lock是一个类，不是java关键字。Concurrent包中的对象。
Synchronized不需要用户自己释放锁，Lock必须手动释放锁。
java.util.concurrent.Lock：
Lock是一个接口。

public interface Lock(){    void lock();    void lockInterruptibly() throws InterruptedException;    boolean tryLock();    boolean tryLock(longtime,TimeUnit unit )throwsInterruptedException;    void unlock();}//其中lock() tryLock() tryLock(long time,TimeUnit unit) lockInterruptibly()是用来获取锁的unlock()是用来释放锁的

lockInterruptibly

通过这个方式获取锁的话，如果线程正在等待获取锁，安么这个线程能够响应中断，即中断线程的等待状态。也就是说，当2个线程同时通过lock.lockInterruptibly()想获取锁，如果线程A获取到了锁，线程B只有等待，那么线程B调用threadB.Interrupt()能够中断线程B的等待过程。

当一个线程获取到了锁之后，是不会被interrupt方法打断的。
当通过lockInterruptibly（）方法 获取到某个锁，如果获取不到，只有进行等待的情况下，是可以被打断的
而用synchronized（）如果处于等待状态，是无法被中断的，只有一直等待下去。
tryLock()方法是有返回值的，表示尝试获取锁，获取成功返回true，失败返回false。