javaSE：不同方式线程创建；线程安全问题

目录

1、线程基本知识：

2、Thread方式创建线程

3、Runnable接口方式创建线程

4、线程安全问题

4.1、同步代码块

4.2、synchronized修饰

4.3、Lock锁

1、线程基本知识：

2、Thread方式创建线程

 //方式1、
 public class Thread_lianxi extends Thread {
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("run:"+i);
        }
    }
}
public class Thread_lianxi01 {
    public static void main(String[] args) {
        Thread_lianxi t=new Thread_lianxi();
        t.start();	//和直接调用run方法，是有区别的【直接调用run（），是一个单线程】
        for(int i=0;i<5;i++){
            System.out.println("main:"+i);
        }
    }
}
//java使用抢占式调度，优先级相同，所以随机选一个先执行
main:0
run:0
main:1
run:1
main:2
run:2
main:3
run:3
main:4
run:4
 
//一
public class Thread_lianxi02 extends Thread {
    @Override
    public void run() {
        //1
       // String name = getName();
        //System.out.println(name);//Thread-0   Thread-1

        Thread th=new Thread();
        System.out.println(th);//Thread[Thread-2,5,main]    Thread[Thread-3,5,main]

        String name = th.getName();
        System.out.println(name);//Thread-3 Thread-2
        //2 链式编程
        System.out.println(Thread.currentThread().getName());//
        //Thread-2 Thread-0

    }
}
public class Thread_lianxi03 {
    public static void main(String[] args) {
        Thread_lianxi02 t=new Thread_lianxi02();
        t.start();

        new Thread_lianxi02().start();

        System.out.println(Thread.currentThread().getName());
        //main
    }
}
==
//二、
public class MyThread_lianxi extends Thread {
    public MyThread_lianxi(){}
    public MyThread_lianxi(String name){
        super(name);//将线程名称传递给父类，让父类给子线程起一个名字
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
 public class MyThread_lianxi01 {
    public static void main(String[] args) {
        MyThread_lianxi mt=new MyThread_lianxi();
        mt.setName("小强");
        mt.start();//小强

        new MyThread_lianxi("旺财").start();//旺财
    }
}


public class sleep_lainxi {
    public static void main(String[] args) {
        for (int i = 0; i <=10; i++) {
            System.out.println(i);

            try {
                Thread.sleep(1000);//毫秒为单位 //【一秒打印一次i】
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、Runnable接口方式创建线程

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.print(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
public class main {
    public static void main(String[] args) {
        RunnableImpl run=new RunnableImpl();
        Thread t=new Thread(run);
        t.start();

        for (int i = 0; i <= 5; i++) {
            System.out.print(Thread.currentThread().getName()+"-->"+i);
        }
    }
}//main-->0Thread-0-->0main-->1Thread-0-->1main-->2Thread-0-->2main-->3Thread-0-->3main-->4Thread-0-->4main-->5Thread-0-->5

4、线程安全问题

4.1、同步代码块

public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    //创建一个锁对象
    Object obj=new Object();
    @Override
    public void run() {
     //使用死循环
        while(true){
            //创建同步代码块，让三个线程重复执行
            synchronized (obj){
                if(ticket>0){
                    //因为使共享数据，为了提高线程安全问题出现概率，让程序睡眠一下，此时线的程暂时失去程序的执行权
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
     }
}
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

4.2、synchronized修饰

 public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    @Override
    public void run() {
        while(true){
           payTicket();
            }
        }
        public synchronized void payTicket(){
            if(ticket>0){
                //因为使共享数据，为了提高线程安全问题出现概率，让程序睡眠一下，此时线程暂时失去程序的执行权
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

4.3、Lock锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
	//1
    Lock l=new ReentrantLock();

    @Override
    public void run() {
        while(true){
			//2
            l.lock();

            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
			//3
            l.unlock();
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}
==

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    Lock l=new ReentrantLock();

    @Override
    public void run() {
        while(true){
            l.lock();

            if(ticket>0){
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    l.unlock();//无论程序是否异常，都会把锁释放
                }
            }
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}