Java基础--多线程01

多线程

线程相关知识

进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；

线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行；

一个进程中至少有一个线程；

JavaVM启动的时候会有一个java.exe进程，该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程；

扩展：其实jvm启动不止一个线程，还有负责垃圾回收机制的线程；

如果自定义一个线程

Java提供了该事物就是：Thread类；

创建线程有两种方式

方式一：继承Thread类

定义类继承Thread；

复写Thread类中的run方法（将自定义代码存储在run方法中，让线程运行）；

调用线程的start方法，该方法两个作用：开启线程，调用run方法；

class Test extends Thread
{
Test(String name)
{
super(name);
}
public void run()
{
for(int x=0; x<60; x++)
{
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
}
}
}
class ThreadTest
{
public static void main(String[] args)
{
Test t1 = new Test("one---");
Test t2 = new Test("two+++");
t1.start();
t2.start();
for(int x=0; x<60; x++)
{
System.out.println("main....."+x);
}
}
}

方式二：实现Runnable接口

定义类实现Runnable接口；

覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中；

将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数（Thread(Runnbale target)）；

调用Thread类的start方法开启线程并调用Runnable接口子类的run方法（将Runnable接口的子类对象传递给Thread的构造函数是因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确该方法所属的对象）；

class Ticket implements Runnable//extends Thread
{
private  int tick = 100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
class  TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建了一个线程；
Thread t2 = new Thread(t);//创建了一个线程；
Thread t3 = new Thread(t);//创建了一个线程；
Thread t4 = new Thread(t);//创建了一个线程；
t1.start();
t2.start();
t3.start();
t4.start();
}
}

实现方式和继承方式的区别：

继承Thread：线程代码存放在Thread子类run方法中；

实现Runnable：线程代码存放在接口的子类的run方法中；

实现方式的好处：避免了单继承的局限性，在定义线程时，建议使用实现方式；

为何要覆盖run方法

　　Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法；也就是说Thread类中的run方法，用于存储线程要运行的代码；

线程的运行状态

线程都有自己默认的名称：

Thread-编号，该编号从0开始

currentThread()：获取当前线程对象（该方法是静态的）；

getName()：获取线程名称；

setName()：设置线程名称，或者构造函数；

多线程的安全问题

原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句值执行了一部分，还没有执行完，另一个线程参与进来执行导致共享数据的错误；

解决办法：对多条操作共享数据的语句，只能让一个线程执行完，再执行过程中，其他线程不可以参与执行；

java对于多线程的安全问题提供了专业的解决方式——同步代码块，同步函数，同步的两种表现形式：

同步代码块，格式：

synchronized(对象)//可以是任意对象；
{
需要被同步的代码；
}

class Ticket implements Runnable
{
private  int tick = 1000;
Object obj = new Object();
public void run()
{
while(true)
{
synchronized(obj)
{
if(tick>0)
{
//try{Thread.sleep(1
4000
0);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
}
class  TicketDemo2
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

知识点a.对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即便获取cpu执行权，也进不去，因为没有获取锁；

知识点b.函数需要被对象调用，那么函数都有一个所属对象引用，同一个类中的函数间调用默认就是this；

同步函数：同步函数只需将synchronized放在函数类型前面修饰函数即可，根据以上知识点同步函数使用的锁是this；

静态函数的同步方法：使用的锁是该方法所在类的字节码文件对象，类名.class;

class Ticket implements Runnable{
private static  int tick = 100;
//Object obj = new Object();
boolean flag = true;
public  void run(){
if(flag){
while(true){
synchronized(Ticket.class){
if(tick>0){
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
}
}
}
}else
while(true)
show();
}
public static synchronized void show(){
if(tick>0){
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
}
}
}
class  StaticMethodDemo{
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}

同步的前提：

必须要有两个或者两个以上的线程；

必须有多个线程使用同一个锁；

必须保证同步中只能有一个线程在运行；

同步的好处：解决了多线程的同步问题；

弊端：多个线程都需要判断锁，较为消耗资源；

如何确定程序是否有安全问题？

明确哪些代码是多线程运行代码；

明确共享数据；

明确多线程运行代码中哪些语句是操作共享数据的；

死锁：同步中嵌套同步（该种方式如果使用的是同一个锁容易造成死锁）

class Test implements Runnable{
private boolean flag;
Test(boolean flag){
this.flag = flag;
}
public void run(){
if(flag){
while(true){
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"...if locka ");
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"..if lockb");
}
}
}
}else{
while(true){
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"..else lockb");
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+".....else locka");
}
}
}
}
}
}
class MyLock{
static Object locka = new Object();
static Object lockb = new Object();
}
class  DeadLockTest{
public static void main(String[] args) {
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}