标签归档:Java

随机存储实现动态数组ArrayList

1、List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package com.yusian;
 
public interface List<E> {
 
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 获取数组长度
	 * @return 数组长度
	 */
	public int size();
 
	/**
	 * 是否为空
	 * @return true / false
	 */
	public boolean isEmpty();
 
	/**
	 * 是否包含某元素
	 * @param element
	 * @return true / false
	 */
	public boolean contains(E element);
 
	/**
	 * 添加元素,默认添加到末尾位置
	 * @param element
	 */
	public void add(E element);
 
	/**
	 * 获取元素
	 * @param index 索引
	 * @return 值
	 */
	public E get(int index);
 
	/**
	 * 替换元素
	 * @param index 索引
	 * @param element 元素
	 * @return 原元素内容
	 */
	public E set(int index, E element);
 
	/**
	 * 添加元素
	 * @param index 索引
	 * @param element 元素值
	 */
	public void add(int index, E element);
 
	/**
	 * 移除元素
	 * @return 返回被移除元素
	 */
	public E remove(int index);
 
	/**
	 * 获取元素索引
	 * @param element
	 * @return 索引
	 */
	public int indexOf(E element);
 
	/**
	 * 清除数组
	 */
	public void clear();
}

2、AbstractList

继续阅读

Java基础之多线程的基本实现

1、实现方式一:继承Thread类,重写run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Demo{
	public static void main(String [] args){
		SAThread thread1 = new SAThread();
		SAThread thread2 = new SAThread();
		thread1.start();
		thread2.start();
	}
 
}
class SAThread extends Thread{
	public void run(){
		System.out.println("SAThread-->"+Thread.currentThread());
	}
}

运行结果:
SAThread–>Thread[Thread-1,5,main]
SAThread–>Thread[Thread-0,5,main]

2、实现Runnable接口,创建Thread对象时将该接口实例传进去即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Demo{
	public static void main(String [] args){
		SARunnable runnable = new SARunnable();
		Thread thread1 = new Thread(runnable);
		Thread thread2 = new Thread(runnable);
		thread1.start();
		thread2.start();
	}
 
}
class SARunnable implements Runnable{
	public void run(){
		System.out.println("SAThread-->"+Thread.currentThread());
	}
}

运行结果:
SAThread–>Thread[Thread-1,5,main]
SAThread–>Thread[Thread-0,5,main]

Java基础之synchronized同步的使用

0、有关多线程的实现先参考:Java基础之多线程的基本实现
1、两个线程访问同一个对象,如果没有同步的限制,会出现一个意想不同的问题;
2、比如对象成员属性int i = 100;某方法每执行一次都会对该值进行减1操作,直接为0结束;
3、单次调用的基本流程应该是:start->{body}->end;但从start到end这个过程是需要时间的;
4、假设是完整过程是A->B->C,如果两个线程同时执行则会出现A调用还未结束B即开始调用;
5、理想的过程是A1->B1->C1->A2->B2->C2->A3->B3->C3,两个线程一起来则会出现A1->A2->B1->C1->B2->C2;
6、为了保证A->B->C这三步能不被中断,完整地一个一个执行,则需要对A->B->C进行加锁保护;
7、加锁保护即使之同步,使开始A就到C之后再重新开启一个新过程;
8、代码块需要加锁则使用修饰词synchronized(){}将代码包含在大括号内;
9、整个方法需要加锁则在方法修饰词中加synchronized关键字
参考代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Demo{
	public static void main(String [] args){
		// 创建一个Service对象,使两个线程同时对该对象进行操作
		Service service = new Service();
		// 线程1访问Service对象的第一个方法,因为同步方法,service对象会被锁定
		Thread thread1 = new Thread(new Runnable(){
			public void run(){
				service.fun1();
			}
		});
		// 线程2访问Service对象的第二个方法
		// 由于第二个方法包含synchronized修饰
		// 并且同步加锁的是service对象本身;
		// 所以线程2只能等待service解锁后才能执行
		Thread thread2 = new Thread(new Runnable(){
			public void run(){
				service.fun2();
			}
		});
		thread1.start();
		thread2.start();
	}
 
}
// 同步方法的两种写法
class Service{
	// 1、在方法修饰词前加synchronized
	public synchronized void fun1(){
		try{
			Thread.sleep(3000);
		}catch(Exception e){
			System.out.println(e);
		}
		System.out.println("fun1");
	}
	// 2、在代码块中加synchronized(){}来修饰
	public void fun2(){
		synchronized(this){
			System.out.println("fun2");
		}
	}
}

运行结果:
fun1
fun2
说明线程2在等待线程1结束后才执行,如果将方法fun2里的synchronized修饰词去掉则线程2会先执行完!