-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
1、概述
进程是一个正在执行中的程序，每一个进程执行都有一个执行的顺序，该顺序是一个执行路径，或则叫一个控制单元。
线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。
一个进程至少有一个线程。
java虚拟机启动的时候会有一个进程叫着java.exe，该进程中至少有一个线程，在负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程可以起个名字称之为主线程。
扩展：其实更细节说明虚拟机，jvm启动不止一个线程，还有负责垃圾回收机制的线程。
2、创建线程-继承Thread类
将类声明为Thread的子类，该子类应重写Thread类的run方法，接下来可以分配并启动该子类的实例。
详细步骤：
1.定义Thread类
2.复写Thread累的run方法，目的：将自定义的代码存储在run方法中，让线程运行。
3.调用线程的start方法
class Demo extends Thread {
private String name;
Demo(String name) {
this .name=name;
//super(name);
}
public void run() {
for (int x = 0; x <60; x++)
{
System.out.println(name+"run----" + x);//(Thread.currentThread() == this) + "...."+ this.getName() + "run----" + x);
}
}
}
该方法有两个作用：开启动线程，调用run方法。
发现运行结果每一次都不同，因为多个线程都获取cpu执行权，cpu执行到谁，谁就运行
明确一点，在某一个时刻，只能有一个程序在运行（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权
这就是多线程的一个特性：随机性，谁抢到执行谁，至于执行多长，cpu说的算。
3、run和start
联系：线程调用start()方法实际上是调用的run()方法，run()方法中存储的线程运行的代码
区别：调用start()方法是启动线程，直接调用run()方法的话，那么就和调用普通的方法是一样的，没有启动线程。
4、线程运行状态
线程的第一种状态：被创建
经过start方法达到运行状态，在运行时，经过sleep(time)方法可以到达冻结状态，经过time时间后，重新回到运行状态。
在运行时，还可以经过wait()方法冻结状态。经过notity()；方法回到运行状态。
在运行过程中经过stop()；方法可以让线程消亡，run方法执行完后也会消亡。
（临时）阻塞状态：具备运行资格，但没有执行权，跟运行状态互通。在冻结状态被唤醒时，不一定马上就会运行，也会到临时状态。
5、获取线程对象以及名称
原来线程都有默认的名称，Thread-编号，该编号从0开始。
cunrrentThread()；获取当前线程对象。
getName()；获取线程名称
设置线程名称：setName();
6、售票的例子
需求：一个简单的卖票程序
多个窗口同时卖票。
public class Tick extends Thread {
private int tick = 10;
public void run() {
while (tick > 0) {
System.out.println(Thread.currentThread().getName() + "卖了第"
+ (tick--) + "张票");
}
}
}
public class Text {
public static void main(String[] agrs) {
new Tick().start();
new Tick().start();//这样相当于开了3个线程，就是3个窗口
new Tick().start();//但是这样相当于各个窗口买各自的票，而不是共享票
}
}
7、创建线程-实现Runable接口
创建线程的另一种方法：申明实现Runable接口。
步骤：
1.定义类实现Runable接口
2.覆盖Runable接口中的run方法。（将线程要运行的代码放在run方法中）
3通过Thread类建立线程对象
4.将Runable接口的子类对象作为实际参数传递给Thread类的构造函数
5.调用Thread类的start方法开启线程并调用Runable接口子类的run方法。
class Ticket implements Runable
{
private int tick=100;
public void run()
{
if(tick>0)
{
System.out.println(Thread.currentThread()+"sale..."+tick);
}
}
}
class TicketDemo
{
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子类的方法中
实现Runnable：线程代码存放在接口的子类的方法中。
8、多线程的安全问题
（1）问题原因：当多条语句在操作共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程参与进来执行，导致共享数据的错误。
（2）解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
（3）Java中解决方式：同步代码块
synchronized (obj) {操作共享数据的代码}
9、多线程同步代码块
对象如同锁，持有锁的线程可以在同步中执行，没有持有锁锁的线程即使获得cpu执行权，也进不去，因为没有获取锁。
同步的前提：
1.必须要有两个或两个以上的线程。
2.必须是多个线程使用同一锁。
必须保证同步中只能有一个线程在运行。
好处：解决了多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源。
class Ticket implements Runnable// extends Thread
{
private static int tick = 100;
Object obj = new Object();
public void run() {
while (true) {
synchronized (obj) {
if (tick > 0) {
try {
Thread.sleep(10);
} catch (Exception e) {
}
System.out.println(Thread.currentThread().getName()
+ "----sale:" + tick--);
}
}
}
}
}
10、多线程同步函数
如何找问题？
明确哪些代码是多线程运行代码。明确共享数据。明确多线程运行代码中哪些语句是操作共享数据的。
把关键字synchronized作为修饰符修饰函数，就可以让该函数称为同步函数。
class Bank {
private int sum;
public synchronized void add(int n) {
sum += n;
try {
Thread.sleep(10);
} catch (Exception e) {
}
System.out.println("sum=" + sum);
}
}
class ChuHu implements Runnable {
private Bank b = new Bank();
public void run() {
for (int x = 0; x < 3; x++) {
b.add(100);
}
}
}
11、同步函数的锁是this
同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this
12、静态同步函数的锁是class对象
如果同步函数被静态修饰后，使用的锁不是this了？
通过验证，发现不光是this，因为静态函数也不可以定义this
静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象：类名.class，该对象的类型是Class。
静态的同步方法中，使用的锁是该方法所在类的字节码文件对象，类名.class
13、多线程单例设计模式懒汉式
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
//--->A;
s = new Single();
}
}
return s;
}
}
扫一扫
946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
