java基础之多线程
来源：互联网 发布：淘宝网黑盘羊沉香好吗 编辑：程序博客网 时间：2024/06/09 16:36
引入：多线程和进程的区别
进程：正在执行的程序，每一个进程执行都有一个执行顺序路径，并封装为控制单元，一个进程至少有一个线程。
线程：进程中一个独立的控制单元，线程在控制着进程的执行，一个进程至少有一个线程。主线程：该线程中至少一个线程负责java程序的执行，而且这个线程的运行的代码存在于main方法中，该线程称之为主线程。
1、自定义线程（继承Thread类）
创建线程步骤：
（1）定义继承Thread类
（2）复写Thread类中run方法，将自定义代码存储在run方法中，让线程运行
（3）调用线程的start方法。该线程开始执行，jvm调用该线程的run方法。
示例如下：
class Demo extends Thread{ public void run() { for(int x=0;x<60;x++) { System.out.println("Demorun+"+x); } }}class ThreadDemo{ public static void main(String[] args) { Demo d=new Demo(); d.start(); for(int x=0;x<60;x++) { System.out.println("HelloWorls+++++"+x); } }}注释：程序解读，每次结果不同，因为多个线程都在抢夺cpu的执行权，某一时刻只能只有一个程序在运行，cpu做着快速的执行切换。这就是多线程的特点：随意性。
- 1.1 创建线程run和start特点，为什么要覆盖run方法？
Thread类用于描述进程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。
- 1.2 获取线程对象以及名称
(1)Thread类中有setName()和getName()方法
(2)static Thread currentThread() 返回对当前正在执行的线程对象的引用
事例如下：
class Test extends Thread{ private String name; Test(String name) { super(name); } public void run() { for(int x=0;x<60;x++) { //读取线程名称的方法应用 System.out.println(this.getName()+"+run+"+x); System.out.println(Thread.currentThread().getName()+"run---"+x); } }}class ThreadDemo{ 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); } }}- 1.3 练习：简单的买票程序
class Ticket extends Thread{ private static int tick=100;//因为是四个窗口共享400张票，static用于类加载时候 的初始化数据与对象无关 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 t1=new Ticket(); Ticket t2=new Ticket(); Ticket t3=new Ticket(); t1.start(); t2.start(); t3.start(); }}2、创建线程（实现Runnable接口）
步骤：
(1) 定义实现Runable接口中的方法
(2) 覆盖Runable接口中的方法
(3)通过Thread类建立线程对象
(4)将Runable接口的子类对象作为实际参数传递给Thread类的构造函数
//定义实现Runnable接口的方法，覆盖class Ticket implements Runnable{ 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); t1.start(); t2.start(); t3.start(); }}2.1 为什么要将Runnable接口的子类对象作为实际参数给Thread方法
Runable接口：应该由打算通过某一线程执行其实例的类来实现。类比较定义一个称为run的无参数方法。Thread类中有一个方法Thread(Runable target)接受一个Runable接口对象。2.2 继承Thread类和实现Runable接口的方法的区别
(1)继承Thread类是将线程代码放到Thread子类的run方法中。
(2)实现Runnable类，线程代码存放在接口子类的run方法中。实现方式避免了单继承的局限性。2.3 Thread类、Runnable接口内部源码关系模拟代码
Thread类
class Thread{ private Runnable r ; Thread() {} Thread(Runnable r) { This.r = r; } public void run() { if(r !=null) r.run(); } public void start() { run(); }}class ThreadImpl implements Runnable{ public void run() { System out println("runnable run" ); }} class ThreadDemo { public static void main(String[] args) { ThreadImpl i = new ThreadImpl(); Thread t = new Thread(i); t.start(); } }Runable 接口
class SubThread extends Thread{ public void run() { System out println("hahah" ); }}class ThreadDemo{ public static void main(String[] args) { SubThread s = new SubThread(); s.start(); }}3、多线程的安全问题---------事例引入：class Ticket implements Runnable
{
private int tick=10;
public void run()//不可抛异常，run是复写了接口异常
{
while(true)
{
if(tick>0)
{
try{Thread.sleep(10);
}
catch(Exception e){
}
System.out.println(Thread.currentThread().getName()+”run–>”+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);
t1.start();
t2.start();
t3.start();
}
}
出现了打印错票的问题0、-1，出现了安全问题。**分析**：当多余语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一线程参与进来执行。导致共享数据的错误**解决方法**：对多条操作共享数据时，只能让一个线程执行完，在执行完成后，其他线程不可以参与其中。 - 3.1 **同步代码块**对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取了cpu的执行权也进不去，因为没有锁。java对多线程的安全问题提供了专业的解决方式:synchronized(对象)
{
需要同步的代码
}
前提：(1)必须由两个或两个以上的线程(2)必须多个线程使用同一个锁(3)必须保证同步中只能由一个线程执行好处：解决了多线程的安全的问题。弊端：多个线程需要判断锁，较为消耗资源。事例说明：class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();//这个不要忘，这个要使用同一个锁
public void run()//不可抛异常，run是复写了接口异常
{
while(true)
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);
catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”run–>”+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);
t1.start();
t2.start();
t3.start();
}
}
- **3.2 同步函数** - **3.2.1银行存款事例的应用**/*需求：银行有一个金库，有两储户分别存300，每次都存100，存三次
注意事项：(1)明确哪些代码是多线程运行代码
(2)明确共享数据
(3)明确多线程运行代码中哪些语句是操作共享数据*/
class Bank
{
private int sum=0;
public synchronized void add(int n)
{
sum=sum+n;
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”sum–>”+sum);
}
}
class Cus implements Runnable
{
private Bank b=new Bank();
public void run()
{
for(int x=0;x<3;x++)
{
b.add(100);
}
}
}
class BankDemo
{
public static void main(String[] args)
{
Cus c=new Cus();
Thread t1=new Thread(c);
Thread t2=new Thread(c);
t1.start();
t2.start();
}
}
- **3.2.2 同步函数在卖票程序中的应用**class Ticket implements Runnable
{
private int tick=100;
public synchronized void run()//具有同步特性，0进入后就锁了，0进入就锁了，0计入 后循环出不来，要清楚哪些需要同步
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+”sale–>”+tick–);
}
}
}
}
class Ticket implements Runnable
{
private int tick=100;
public void run()
{
while(true)
{
this.show();
}
}
public synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
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);
t1.start();
t2.start();
t3.start();
}
}
- **3.2.3 对同步函数锁的讨论**函数需要被对象调用。那么函数都有一个所属对象引用，this，所以同步函数用锁为this/*
用程序加以验证：（前提：必须由两个或两个以上的线程、必须多个线程使用同一个锁、必须保证同步中只能由一个线程执行)
所以用两线程卖票，一个在同步代码块，一个在同步函数，如果同步则不会有错票*/
class Ticket implements Runnable
{
private int tick=100;
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(this)//第一个线程为同步代码块且锁是this
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”one”+tick–);
}
}
}
}
else
while(true)
show();//第二个线程使用同步函数，锁也是this
}
public synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
class TicketDemo
{
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();
}
}
结果没有错票，说明同步函数的锁为this。- **3.2.4 静态同步函数锁**静态同步函数锁为class对象/静态进内存没对象，由类调用，类进入内存先封装成class的对象，即Ticket.class/
class Ticket implements Runnable
{
private static int tick=100;//注意设置成静态
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(Ticket.class)//使用锁Ticket.class
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”one”+tick–);
}
}
}
}
else
while(true)
show();
}
public static synchronized void show()//注意设置成静态,静态进内存没有对象，由 类调用，类进内存先封装成class的对象Ticket.class
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
class TicketDemo
{
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();
}
}
同样程序可以正常的运行。## 4 单例设计模式和死锁 ## - **4.1 单例设计模式**class Single
{
private static Single s=null;
private Single(){}
public static Single getInstance()
{
synchronized(Single.class)
{
if(s==null)
s=new Single();
}
}
return s;
}
是延时加载的方式。当多线程访问懒汉式的方法内对共性数据进行多条语句的操作，但是容易产生安全问题，为了解决，加入了同步机制，解决安全问题。同时使用双重判断的形式解决效率的问题。 - **4.2 死锁** (1)同步中嵌套同步，锁却不同。同步函数中有同步代码块，同步代码块中有同步函数。class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(obj)//同步代码块中有同步函数
{
show();
}
}
}
else
while(true)
show();
}
public synchronized void show()//同步函数中还有同步代码块
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
}
class TicketDemo
{
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();
}
}
(2)一个死锁的实例：class Test implements Runnable
{
boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println(“if locka”);
synchronized(MyLock.lockb)
{
System.out.println(“if lockb”);
}
}
}
else
{
synchronized(MyLock.lockb)
{
System.out.println(“else lockb”);
synchronized(MyLock.locka)
{
System.out.println(“else locka”);
}
}
}
}
}
class MyLock
{
static Object locka=new Object();
static Object lockb=new Object();
}
class Demo
{
public static void main(String[] args)
{
Test t1=new Test(true);
Test t2=new Test(false);
Thread t3=new Thread(t1); Thread t4=new Thread(t2); t3.start(); t4.start();}}
“` 
程序终止，无法继续进行。
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- JAVA基础之多线程
- Java基础之多线程
- java基础之多线程
- Java基础之多线程
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Collections.sort方法（可以根据集合中类的属性的比较对集合内的类进行排序）
- Android float，int等与string的转换方法
- unique_ptr
- SSL通信过程抓包分析
- Spring定义的7种不同的事务传播行为
- java基础之多线程
- 1003. Emergency (25)
- UVA - 227 Puzzle
- GitHub Hacking
- Swift - 元组的用法
- OFBiz安装注意事项：不要启动Tomcat
- shared_ptr
- 【转自网上，分享更多人看到】创建符号链接 “asm”: 不支持的操作
- Android decode
