1. Лекция 2. «Многопоточность»

3. public abstract class MyAbstractClass {
private int a = 0;
public int getSum(){
return a + getB();
}
protected int getA(){
return a;
}
abstract int getB();
}
public interface MyInterface {
int getDif();
}

4. public class MyClass extends MyAbstractClass implements MyInterface {
private int b = 1;
public int getB(){
return b;
}
public int getDif(){
return getA() - b;
}
}
public class MyClassChild extends MyClass implements Interface1, Interface2{
…
}

5. public static void main(String[] args) {
//MyAbstractClass aObject = new MyAbstractClass(); - ошибка
MyClass object1 = new MyClass();
int result1 = object1.getSum();
int result2 = object1.getDif();
doSomething(object1);
MyInterface object2 = new MyClass();
//int result3 = object2.getSum(); - ошибка
int result4 = object2.getDif();
doSomething(object2);
}
public static void doSomething(MyInterface object){
//MyClass object3 = object; - ошибка
//int result5 = object.getSum(); - ошибка
int result6 = object.getDif();
}

7. static Class<T> forName(String className)
String getCanonicalName()
Fields[] getField(String name)
Class[] getInterfaces()
Method[] getMethods()
Constructor[] getConstructors()

8. public Class<?> getClass()
public String toString()
public boolean equals(Object obj)
public int hashCode()
protected Object clone()

9. Stack

13. public class GenericExample<T> {
private T value;
public GenericExample(T value){
this.value = value;
}
public T getT(){
return value;
}
public static void main(String[] args) {
GenericExample<Integer> intObject = new GenericExample<Integer>(1);
Integer valueInteger = intObject.getT();
GenericExample<String> stringObject = new GenericExample<String>("word");
String valueString = stringObject.getT();
}
}

14. public class LongId<T> {
private long id;
public LongId(long id){
this.id = id;
}
public long getLong(){
return id;
}
}
public void manyIdsInParams(long userId, long serverId, long adress){…}
public void manyIdsInParams(LongId<User> userId,
LongId<Server> serverId,
LongId<Adress> adress){…}

24. public class HelloRunnable implements Runnable {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new Thread(new HelloRunnable())).start();
}
}

25. public class HelloThread extends Thread {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new HelloThread()).start();
}
}

27. try {
Thread.sleep(5000);
} catch (InterruptedException e) { // We've been interrupted.
return;
}
for (int i = 0; i < inputs.length; i++) {
heavyTask(inputs[i]);
if (Thread.interrupted()) { // We've been interrupted.
return;
}
}

28. public class HelloThread extends Thread {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
Thread thread = new HelloThread();
thread.start();
thread.join();
System.out.println("Hello from the main!");
}
}

29. public class HelloThread extends Thread {
private StringBuilder builder;
public HelloThread(StringBuilder builder){
this.builder = builder;
}
public void run() {
builder.append("Hello from a thread!");
}
public static void main(String args[]) {
StringBuilder builder = new StringBuilder();
Thread thread = new HelloThread();
thread.start();
builder.append("Hello from the main!");
}
}

30. public synchronized void increment() {
j++;
}
public void addName(String name) {
synchronized(lockObject) {
lastName = name;
nameCount++;
}
nameList.add(name);
}

31. public class TwoMonitors {
private long c1 = 0;
private long c2 = 0;
private Object lock1 = new Object();
private Object lock2 = new Object();
public void c1Up() {
synchronized(lock1) {
c1++;
}
}
public void c2Up() {
synchronized(lock2) {
c2++;
}
}
}

32. public void c1c2Up() {
synchronized(lock1) {
c1++;
synchronized(lock2) {
c2++;
}
}
}
public void c2c1Up() {
synchronized(lock2) {
c2++;
synchronized(lock1) {
c1++;
}
}
}

33. private boolean needDoSomething;
public void run() {
while(true){
if(needDoSomething){
doSomething();
}
Thread.sleep(1000);
}
}