База ответов ИНТУИТ

Программирование на Java

<<- Назад к вопросам

Укажите возможный результат выполнения следующего кода:
                public abstract class SomeClass implements Runnable {                    public final static Object one = new Object(), two = new Object();                    public static void main(String s[]) {                        Thread t1 = new Thread() {                            public void run() {                                synchronized (one) {                                    synchronized (two) {                                        System.out.print("1");                                    }                                }                            }                        };                        Thread t2 = new Thread() {                            public void run() {                                synchronized (two) {                                    try {                                        Thread.sleep(1000);                                    } catch (InterruptedException e) {                                        e.printStackTrace();                                    }                                    synchronized (one) {                                        System.out.print("2");                                    }                                }                            }                        };                        t1.start();                        t2.start();                    }                }            

(Отметьте один правильный вариант ответа.)

Варианты ответа
программа завершит работу, на консоли появится 1
программа не завершит работу
программа не завершит работу, на консоли появится 12
программа завершит работу, на консоли появится 12(Верный ответ)
программа завершит работу, на консоли появится 2
Похожие вопросы
Укажите результат выполнения следующего кода:
                public abstract class SomeClass implements Runnable {                    public final static Object one = new Object(), two = new Object();                    public static void main(String s[]) {                        Thread t1 = new Thread() {                            public void run() {                                synchronized (one) {                                    try {                                        Thread.sleep(1000);                                    } catch (InterruptedException e) {                                        e.printStackTrace();                                    }                                    synchronized (two) {                                        System.out.print("1");                                    }                                }                            }                        };                        Thread t2 = new Thread() {                            public void run() {                                synchronized (two) {                                    synchronized (one) {                                        System.out.print("2");                                    }                                }                            }                        };                        t1.start();                        t2.start();                    }                }            
Укажите возможный результат выполнения следующего кода:
                public abstract class SomeClass implements Runnable {                    public final static Object one = new Object(), two = new Object();                    public static void main(String s[]) {                        Thread t1 = new Thread() {                            public void run() {                                synchronized (one) {                                    synchronized (two) {                                        System.out.print("1");                                    }                                }                            }                        };                        Thread t2 = new Thread() {                            public void run() {                                synchronized (two) {                                    synchronized (one) {                                        System.out.print("2");                                    }                                }                            }                        };                        t1.start();                        t2.start();                    }                }            
Каким будет результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    private Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                lock.wait();                                System.out.print("1");                            } catch (InterruptedException e) {}                        }                    }                    public void notifyThread() {                        synchronized (lock) {                            lock.notify();                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        Thread t = new Thread(new SomeClass() {                            public void run() {                                lock();                                try {                                    Thread.sleep(1000);                                } catch (InterruptedException e) {}                                notifyThread();                            }                        });                        t.start();                        Thread t1 = new Thread(new SomeClass() {                            public void run() {                                unlock();                            }                        });                        t1.start();                    }                }            
Каким будет результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    public static Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                lock.wait();                                System.out.print("1");                            } catch (InterruptedException e) {}                        }                    }                    public void notifyThread() {                        synchronized (lock) {                            lock.notify();                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        final SomeClass c = new SomeClass() {                            public void run() {                                lock();                                notifyThread();                            }                        };                        final SomeClass c1 = new SomeClass() {                            public void run() {                                unlock();                            }                        };                        new Thread(c).start();                        new Thread(c1).start();                    }                }            
Каким будет результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    public Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                lock.wait();                                System.out.print("1");                            } catch (InterruptedException e) {}                        }                    }                    public void notifyThread() {                        synchronized (lock) {                            lock.notify();                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        final SomeClass c = new SomeClass() {                            public void run() {                                lock();                            }                        };                        final SomeClass c1 = new SomeClass() {                            public void run() {                                unlock();                                c.notifyThread();                            }                        };                        new Thread(c).start();                        new Thread(c1).start();                    }                }            
Каким может быть результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    private Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                System.out.print("1");                                lock.wait();                            } catch (InterruptedException e) {}                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        new Thread(new SomeClass() {                            public void run() {                                lock();                            }                        }).start();                        new Thread(new SomeClass() {                            public void run() {                                unlock();                            }                        }).start();                    }                }            
Каким будет результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    private Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                lock.wait();                                System.out.print("1");                            } catch (InterruptedException e) {}                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        new Thread(new SomeClass() {                            public void run() {                                lock();                            }                        }).start();                        new Thread(new SomeClass() {                            public void run() {                                unlock();                            }                        }).start();                    }                }            
Каким будет результат работы следующего кода?
                public abstract  class SomeClass implements Runnable{                    private Object lock = new Object();                    public void lock() {                        synchronized (lock) {                            try {                                lock.wait();                                System.out.print("1");                            } catch (InterruptedException e) {}                        }                    }                    public void notifyThread() {                        synchronized (lock) {                            lock.notify();                        }                    }                    public void unlock() {                        synchronized (lock) {                            lock.notify();                            System.out.print("2");                        }                    }                    public static void main(String s[]) {                        SomeClass c = new SomeClass() {                            public void run() {                                lock();                            }                        };                        SomeClass c1 = new SomeClass() {                            public void run() {                                unlock();                            }                        };                        new Thread(c).start();                        new Thread(c1).start();                        c.notifyThread();                    }                }            
Что будет выведено на экран в результате выполнения следующего кода:
                public class SomeClass {                    public void perform() {                        this.perform(1);                        System.out.print("1");                    }                    public void perform(int val) {                        System.out.print(val);                    }                    public static void main(String[] args) {                        SomeClass c = new SomeClass2();                        c.perform(4);                    }                }                class SomeClass2 extends SomeClass {                    public void perform() {                        super.perform();                        System.out.print("3");                    }                    public void perform(int val) {                        super.perform();                        System.out.print(val);                    }                }            
Укажите результат выполнения следующего кода?
                public class SomeClass {                    public static void main(String[] args) {                        SomeClass c = new SomeChild1();                        ((SomeClass)c).print();                        ((SomeChild1)c).print();                        ((SomeChild2)c).print();                    }                    public void print() {                        System.out.println("SomeClass");                    }                }                class SomeChild1 extends SomeClass {                    public void print() {                        System.out.println("SomeChild1");                    }                }                class SomeChild2 extends SomeClass {                    public void print() {                        System.out.println("SomeChild2");                    }                }